path: root/lib/_ak_ns

#!/usr/bin/env bash
###
### arching-kaos-tools
### Tools to interact and build an Arching Kaos Infochain
### Copyright (C) 2021 - 2025  kaotisk
###
### This program is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### This program is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with this program.  If not, see <http://www.gnu.org/licenses/>.
###
source $AK_LIBDIR/_ak_lib_load
_ak_lib_load _ak_log
_ak_lib_load _ak_script
_ak_lib_load _ak_gpg
_ak_lib_load _ak_fs
_ak_lib_load _ak_zchain

AK_NS_DIR="${AK_WORKDIR}/akns"

_ak_check_and_create_dir ${AK_NS_DIR}

function _ak_ns_create(){
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key name was given"
        exit 1
    fi
    if [ "$(echo -n $1| tr -d '[:alnum:]')" != "" ]
    then
        _ak_log_error "Name $1 is not allowed. Use only letters and numbers"
        exit 1
    fi
    keyname="$1@keynames.kaos.kaos"
    _ak_log_info "Checking for ${keyname}..."
    _ak_gpg_list_secret_keys_long | grep ${keyname} > /dev/null 2>&1
    if [ $? -ne 0 ]
    then
        _ak_log_info "Creating ${keyname}"
        _ak_gpg_create_key ${keyname}
    else
        _ak_log_error "Name ${keyname} already exists"
        exit 1
    fi
}

function _ak_ns_list(){
    _ak_gpg_list_secret_keys_long | grep '@keynames.kaos.kaos' | cut -d ' ' -f 2
}

function _ak_ns_list_long(){
    _ak_gpg_list_secret_keys_long \
        | grep '@keynames.kaos.kaos' \
        | while read key name
    do
        printf '%s %s %s\n'  "${key}" "$(_ak_ns_encode_key ${key})" "${name}"
    done
}

function _ak_ns_resolve_from_key(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    key="$1"
    _ak_log_info "${key} was given"
    if [ ! -f ${AK_NS_DIR}/${key} ]
    then
        _ak_log_error "${key} was not found"
        exit 1
    fi
    _ak_gpg_verify_clear_signature ${AK_NS_DIR}/${key}
}

function _ak_ns_resolve_from_key_with_proof(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    key="$1"
    _ak_log_info "${key} was given"
    if [ ! -f ${AK_NS_DIR}/${key}.map ]
    then
        _ak_log_error "${key} was not found"
        exit 1
    fi
    cat ${AK_NS_DIR}/${key}.map
}

function _ak_ns_resolve_from_key_with_proof_json(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    key="$1"
    json=$(_ak_ns_resolve_from_key_with_proof $key | while read proof resolved; do printf '{"fingerprint":"%s","proof":"%s","resolved":"%s"}' "$1" "$proof" "$resolved";  done)
    if [ $? -ne 0 ]
    then
        _ak_log_error "Something happened"
        exit 1
    fi
    echo $json
}

function _ak_ns_encode_key(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    key="$1"
    _ak_log_info "${key} was given"
    printf '%s' "$(echo -n ${key}|xxd -r -p|base64)"
}

function _ak_ns_decode_key(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    key="$1"
    _ak_log_info "${key} was given"
    printf '%s' "$(echo -n ${key}|base64 -d|xxd -p|tr '[:lower:]' '[:upper:]')"
}

function _ak_ns_resolve_from_name(){
    # $1; exit;;
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No name was given"
        exit 1
    fi
    key_name="$1"
    _ak_log_info "${key_name} was given"
    if [ "${key_name}" == "zchain" ] || [ "${key_name}" == "zconfig" ]
    then
        _ak_log_info "${key_name} search on local secret keychain"
        key="$(_ak_gpg_list_secret_keys_long | grep ${key_name}'@keynames.kaos.kaos' | cut -d ' ' -f 1)"
        if [ ! -n "${key}" ]
        then
            _ak_log_error "${key_name} was not found locally"
            exit 1
        fi
        _ak_ns_resolve_from_key ${key}
    fi
}

function _ak_ns_publish(){
    # $1 $2; exit;;
    _ak_not_implemented "${FUNCNAME}"
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key was given"
        exit 1
    fi
    if [ ! -z $2 ] || [ ! -n "$2" ]
    then
        _ak_log_error "No value was given"
        exit 1
    fi
    if [ "$(echo -n $1| sed -e 's/[A-F0-9]\{40\}//')" != "" ]
    then
        _ak_log_error "$1 is not a valid key"
        exit 1
    fi
    if [ "$(echo -n $2| sed -e 's/[a-f0-9]\{128\}//')" != "" ]
    then
        _ak_log_error "$2 is not a valid hash"
        exit 1
    fi
    key="$(_ak_gpg_list_secret_keys | grep $1)"
    value="$2"
    if [ ! -n "${key}" ]
    then
        _ak_log_error "Key $1 was not found"
        exit 1
    fi
    _ak_log_info "Key $1 was found"
    if [ ! -z $2 ] || [ -n "$2" ]
    then
        _ak_gpg_sign_clear_with_key $key
    fi
}

function _ak_ns_publish2name(){
    # $1 $2; exit;;
    _ak_not_implemented "${FUNCNAME}"
    if [ -z $1 ] || [ ! -n "$1" ]
    then
        _ak_log_error "No key name was given"
        exit 1
    fi
    if [ "$(echo -n $1| tr -d '[:alnum:]')" != "" ]
    then
        _ak_log_error "Name $1 is not allowed. Use only letters and numbers"
        exit 1
    fi
    key="$(_ak_gpg_list_secret_keys_long | grep $1'@keynames.kaos.kaos' | cut -d ' ' -f 1)"
    if [ ! -n "${key}" ]
    then
        _ak_log_error "No key found with name $1"
        exit 1
    fi
    _ak_ns_publish ${key} $2
}

function _ak_ns_publish_zchain(){
    zlatest="$(_ak_zchain_get_latest)"
    zchain_key="$(_ak_gpg_list_secret_keys_long | grep 'zchain@keynames.kaos.kaos' | cut -d ' ' -f 1)"
    if [ ! -n "${zchain_key}" ]
    then
        _ak_log_warning "zchain_key not there"
        _ak_log_info "Creating zchain_key"
        _ak_ns_create zchain
    fi
    zchain_key="$(_ak_gpg_list_secret_keys_long | grep 'zchain@keynames.kaos.kaos' | cut -d ' ' -f 1)"
    zlatest_file="$(_ak_make_temp_file)"
    echo -n ${zlatest} > ${zlatest_file}
    zlatest_csigned_file="$(_ak_make_temp_file)"
    _ak_gpg_sign_clear_with_key ${zlatest_csigned_file} ${zlatest_file} ${zchain_key} 
    if [ -f ${AK_NS_DIR}/${zchain_key} ]
    then
        _ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zchain_key} >> ${AK_NS_DIR}/${zchain_key}.history
    fi
    signed_akfs_map=$(_ak_fs_import ${zlatest_csigned_file})
    if [ -f ${AK_NS_DIR}/${zchain_key}.map ]
    then
        printf '%s %s\n' "$(echo -n $signed_akfs_map)" \
            "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zchain_key})" \
            >> ${AK_NS_DIR}/${zchain_key}.history_map
    fi
    mv ${zlatest_csigned_file} ${AK_NS_DIR}/${zchain_key}
    printf '%s %s\n' "$(echo -n $signed_akfs_map)" \
        "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zchain_key})" \
        > ${AK_NS_DIR}/${zchain_key}.map
}

function _ak_ns_publish_config(){
    zconfig="$(_ak_node_info_ipfs_hash)"
    zconfig_key="$(_ak_gpg_list_secret_keys_long | grep 'zconfig@keynames.kaos.kaos' | cut -d ' ' -f 1)"
    if [ ! -n "${zconfig_key}" ]
    then
        _ak_log_warning "zconfig_key not there"
        _ak_log_info "Creating zconfig_key"
        _ak_ns_create zconfig
    fi
    zconfig_key="$(_ak_gpg_list_secret_keys_long | grep 'zconfig@keynames.kaos.kaos' | cut -d ' ' -f 1)"
    zconfig_file="$(_ak_make_temp_file)"
    echo -n ${zconfig} > ${zconfig_file}
    zconfig_csigned_file="$(_ak_make_temp_file)"
    _ak_gpg_sign_clear_with_key ${zconfig_csigned_file} ${zconfig_file} ${zconfig_key} 
    if [ -f ${AK_NS_DIR}/${zconfig_key} ]
    then
        _ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zconfig_key} >> ${AK_NS_DIR}/${zconfig_key}.history
    fi
    signed_akfs_map=$(_ak_fs_import ${zconfig_csigned_file})
    if [ -f ${AK_NS_DIR}/${zconfig_key}.map ]
    then
        printf '%s %s\n' "$(echo -n $signed_akfs_map)" \
            "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zconfig_key})" \
            >> ${AK_NS_DIR}/${zconfig_key}.history_map

    fi
    mv ${zconfig_csigned_file} ${AK_NS_DIR}/${zconfig_key}
    printf '%s %s\n' "$(echo -n $signed_akfs_map)" \
        "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${zconfig_key})" \
        > ${AK_NS_DIR}/${zconfig_key}.map
}

function _ak_ns_resolve_all_keys(){
    tmpdir="$(_ak_make_temp_directory)"
    cd $tmpdir
    ip a | grep inet6 | sed 's/ *inet6 //g' | cut -d '/' -f 1 > ip_list
    # cat /dev/null > ip_list
    ak network -p 2>/dev/null| jq -r '.[].incoming.ip' | while read ip ; do if [ $ip != null ]; then echo $ip ;fi;done > peer_list
    cat ip_list | while read ip ; do sed -i 's/^'$ip'$//g' peer_list; done
    # cat peer_list | while read ip ; do ak network -p | jq --arg ip "$ip" '.[] | select(.incoming.ip == $ip )' | jq -r '.node_info.keys.[]'> key_list.$ip; done
    cat peer_list | while read ip ; do ak network -p | jq --arg ip "$ip" '.[] | select(.incoming.ip == $ip )' | jq '.node_info.keymaps.[]'> keymaps_list.$ip; done
    # cat peer_list | while read ip
    # do
    #     cat key_list.$ip | while read key
    #     do
    #         ak fs --net-cat-from-map $key > $key && ak fs --import $key
    #     done
    # done
    # cat peer_list | while read ip
    # do
    #     proof="$(cat keymaps_list.$ip | jq -r '.')"
    #     while read key
    #     do
    #         ak fs --net-cat-from-map $key > $key && ak fs --import $key
    #     done
    # done
    cat peer_list | while read ip
    do
        cat keymaps_list.$ip | jq -r '.fingerprint' | while read key
        do
            map="$(cat keymaps_list.$ip | jq -r 'select(.fingerprint == "'$key'")|.map')"
            ak fs --net-cat-from-map $map > $key
            ak fs --import $key
            curl -s http://[$ip]:8610/v0/ns_get/$key > $key.reply
            proof="$(cat $key.reply | jq -r '.proof')"
            resolved="$(cat $key.reply | jq -r '.resolved')"
            key="$(cat $key.reply | jq -r '.key')"
            ak fs --net-cat-from-map $proof > $key.proof
            _ak_gpg_verify_clear_signature $key.proof
            if [ $? -ne 0 ]
            then
                _ak_log_error "Couldn't verify"
                exit 1
            fi
            if [ -f ${AK_NS_DIR}/${key} ]
            then
                _ak_gpg_verify_clear_signature ${AK_NS_DIR}/${key} >> ${AK_NS_DIR}/${key}.history
            fi
            signed_akfs_map=$(_ak_fs_import ${key}.proof)
            if [ -f ${AK_NS_DIR}/${key}.map ]
            then
                printf '%s %s\n' "$(echo -n $signed_akfs_map)" \
                    "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${key})" \
                    >> ${AK_NS_DIR}/${key}.history_map

            fi
            mv ${key}.proof ${AK_NS_DIR}/${key}
            printf '%s %s\n' "$(echo -n $proof)" \
                "$(_ak_gpg_verify_clear_signature ${AK_NS_DIR}/${key})" \
                > ${AK_NS_DIR}/${key}.map
        done
    done
}

_ak_log_debug "_ak_ns loaded $(caller)"