def add_signature(coin_json, role):
"""
"""
_coin = coin_json.copy()
_coin[role] = {
'idurl': my_id.getLocalID(),
'pubkey': key.MyPublicKey(),
}
coin_hash = get_coin_hash(_coin)
_coin[role]['signature'] = key.Sign(coin_hash)
return _coin
def sign_key_info(key_info):
key_info['signature_pubkey'] = key.MyPublicKey()
sorted_fields = sorted(key_info.keys())
hash_items = []
for field in sorted_fields:
if field not in ['include_private', 'signature', 'private', ]:
hash_items.append(strng.to_text(key_info[field]))
hash_text = '-'.join(hash_items)
hash_bin = key.Hash(strng.to_bin(hash_text))
key_info['signature'] = strng.to_text(key.Sign(hash_bin))
return key_info
def sign_key(key_id, keys_folder=None, ignore_shared_keys=False, save=True):
key_id = latest_key_id(strng.to_text(key_id))
if not is_key_registered(key_id):
lg.warn('key %s is not found' % key_id)
return False
if not keys_folder:
keys_folder = settings.KeyStoreDir()
key_object = known_keys()[key_id]
if key_object.signed:
if key_object.signed[1] != key.MyPublicKey():
if ignore_shared_keys:
if _Debug:
lg.dbg(
_DebugLevel,
'skip generating signature for shared key: %r' %
key_id)
return True
raise Exception(
'must not generate and overwrite existing signature for shared key: %r'
% key_id)
signed_key_info = make_key_info(
key_object=key_object,
key_id=key_id,
include_private=not key_object.isPublic(),
generate_signature=True,
)
key_object.signed = (
signed_key_info['signature'],
signed_key_info['signature_pubkey'],
)
known_keys()[key_id] = key_object
if save:
save_key(key_id, keys_folder=keys_folder)
events.send('key-signed',
data=dict(
key_id=key_id,
label=key_object.label,
key_size=key_object.size(),
))
listeners.push_snapshot('key',
snap_id=key_id,
data=make_key_info(
key_object=key_object,
key_id=key_id,
event='key-signed',
include_private=False,
include_local_id=True,
include_signature=True,
include_label=True,
))
return key_object
def sign_key_info(key_info):
key_info['signature_pubkey'] = key.MyPublicKey()
hash_items = []
for field in [
'alias',
'public',
'signature_pubkey',
]:
hash_items.append(strng.to_text(key_info[field]))
hash_text = '-'.join(hash_items)
if _Debug:
lg.dbg(_DebugLevel, hash_text)
hash_bin = key.Hash(strng.to_bin(hash_text))
key_info['signature'] = strng.to_text(key.Sign(hash_bin))
return key_info
def buildDefaultIdentity(name='', ip='', idurls=[]):
"""
Use some local settings and config files to create some new identity.
Nice to provide a user name or it will have a form like: [ip_address]_[date].
"""
if not ip:
ip = misc.readExternalIP()
if not name:
name = ip.replace('.', '-') + '_' + time.strftime('%M%S')
lg.out(4, 'my_id.buildDefaultIdentity: %s %s' % (name, ip))
# create a new identity object
# it is stored in memory and another copy on disk drive
ident = identity.identity(xmlsrc=identity.default_identity_src)
# this is my IDURL address
# you can have many IDURL locations for same identity
# just need to keep all them synchronized
# this is identity propagate procedure, see p2p/propagate.py
if len(idurls) == 0:
idurls.append(b'http://127.0.0.1/%s.xml' % strng.to_bin(name.lower()))
for idurl in idurls:
ident.sources.append(strng.to_bin(idurl.strip()))
# create a full list of needed transport methods
# to be able to accept incoming traffic from other nodes
new_contacts, new_order = buildProtoContacts(ident)
if len(new_contacts) == 0:
if settings.enableTCP() and settings.enableTCPreceiving():
new_contacts['tcp'] = b'tcp://' + strng.to_bin(
ip) + b':' + strng.to_bin(str(settings.getTCPPort()))
new_order.append('tcp')
if settings.enableUDP() and settings.enableUDPreceiving():
_, servername, _, _ = nameurl.UrlParse(ident.sources[0])
new_contacts['udp'] = b'udp://' + strng.to_bin(
name.lower()) + b'@' + strng.to_bin(servername)
new_order.append('udp')
if settings.enableHTTP() and settings.enableHTTPreceiving():
new_contacts['http'] = b'http://' + strng.to_bin(
ip) + b':' + strng.to_bin(str(settings.getHTTPPort()))
new_order.append('http')
# erase current contacts from my identity
ident.clearContacts()
# add contacts data to the local identity
for proto in new_order:
contact = new_contacts.get(proto, None)
if contact is None:
lg.warn('proto %s was not found in contacts' % proto)
continue
ident.setProtoContact(proto, contact)
# set other info
# ident.certificates = []
ident.setDate(time.strftime('%b %d, %Y'))
ident.setPostage(1)
ident.setRevision(0)
ident.setVersion('') # TODO: put latest git commit hash here
# update software version number
# version_number = bpio.ReadTextFile(settings.VersionNumberFile()).strip()
# repo, location = misc.ReadRepoLocation()
# ident.version = (version_number.strip() + ' ' + repo.strip() + ' ' + bpio.osinfo().strip()).strip()
# build a version info
# vernum = bpio.ReadTextFile(settings.VersionNumberFile())
# repo, location = misc.ReadRepoLocation()
# ident.version = (vernum.strip() + ' ' + repo.strip() + ' ' + bpio.osinfo().strip()).strip()
# put my public key in my identity
ident.setPublicKey(key.MyPublicKey())
# generate signature
ident.sign()
# validate new identity
if not ident.Valid():
lg.warn('generated identity is not valid !!!')
return ident
