def fill(self, d):
self._d = d
version_d = d[0]
self.version, idx = STN.strcalc(STN.str2int, d[0], 0)
if self.version in [2, 3]:
hash_len, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.type, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.created, idx = STN.strcalc(STN.str2int, d[idx:idx+4], idx)
self.hashed_data = d[2:idx]
self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx+8], idx)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.hashed_subpkts = [] # dummy settings to make searches easier
self.unhashed_subpkts = [] #
elif 4 == self.version:
import struct
_type_d, idx = STN.strcalc(None, d[idx:idx+1], idx)
self.type = STN.str2int(_type_d)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
# hashed subpackets
subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx)
self.hashed_subpkts = self.__resolve_subpkts(d[idx:idx+subpkts_len])
# hashed data & trailer - should '>i' ever return more than 4 chars?
hashed_data = d[0:idx+subpkts_len]
bigend = struct.pack('>i', len(hashed_data))[-4:]
self.hashed_data = ''.join([hashed_data, version_d, '\xff', bigend])
idx = idx + subpkts_len
# unhashed subpackets
subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx)
self.unhashed_subpkts = self.__resolve_subpkts(d[idx:idx+subpkts_len])
idx = idx + subpkts_len
# attribute convenience
self.keyid = self.__set_subpkt_attr(SIGSUB_SIGNERID) or ''
self.created = self.__set_subpkt_attr(SIGSUB_CREATED) or 0
else:
raise PGPValueError("Unsupported signature version. Received->(%s)" % str(self.version))
self.hash_frag, idx = STN.strcalc(None, d[idx:idx+2], idx)
if self.alg_pubkey in [ASYM_RSA_S, ASYM_RSA_EOS]:
self.RSA, idx = MPI.strcalc_mpi(d[idx:], idx)
elif ASYM_DSA == self.alg_pubkey:
self.DSA_r, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_s, idx = MPI.strcalc_mpi(d[idx:], idx)
elif self.alg_pubkey in [ASYM_ELGAMAL_EOS]:
self.ELGAMAL_a, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_b, idx = MPI.strcalc_mpi(d[idx:], idx)
else:
raise PGPValueError("Unsupported public-key algorithm (%d)." % self.alg_pubkey)
def fill(self, d):
self._d = d
idx = 0
__version_d = d[idx:idx+1]
self.version, idx = STN.strcalc(STN.str2int, __version_d, idx)
if self.version in [2, 3, 4]:
__created_d = d[idx:idx+4]
self.created, idx = STN.strcalc(STN.str2int, __created_d, idx)
if self.version in [2, 3]:
self.__expires_d = d[idx:idx+2]
self.expires, idx = STN.strcalc(STN.str2int, self.__expires_d, idx)
__alg_d = d[idx:idx+1]
self.alg, idx = STN.strcalc(STN.str2int, __alg_d, idx)
# resolve MPIs
if self.alg in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
self.RSA_n, idx = MPI.strcalc_mpi(d[idx:], idx)
self.RSA_e, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.RSA_n._d + self.RSA_e._d
elif ASYM_DSA == self.alg:
self.DSA_p, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_q, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_g, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_y, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.DSA_p._d + self.DSA_q._d + self.DSA_g._d + self.DSA_y._d
elif self.alg in [ASYM_ELGAMAL_E, ASYM_ELGAMAL_EOS]:
self.ELGAMAL_p, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_g, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_y, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.ELGAMAL_p._d + self.ELGAMAL_g._d + self.ELGAMAL_y._d
else:
raise NotImplementedError("Unsupported key algorithm. Received alg->(%s)" % self.alg)
# set fingerprint
if self.version in [2, 3]:
integer_data = self.RSA_n._int_d + self.RSA_e._int_d
self.fingerprint = md5.new(integer_data).hexdigest().upper()
# see fingerprint/id notes in doc/NOTES.txt
self.id = STN.str2hex(self.RSA_n._int_d[-8:])
elif 4 == self.version:
f = ['\x99']
f_data = ''.join([__version_d, __created_d, __alg_d, self._mpi_d])
length = len(f_data)
hi = (chr((0xffff & length) >> 8)) # high order packet length
lo = (chr(0xff & length)) # low order packet length
f.append(hi + lo)
f.append(f_data)
self.fingerprint = sha.new(''.join(f)).hexdigest().upper()
# see fingerprint/id notes in doc/NOTES.txt
self.id = self.fingerprint[-16:]
else: # unsupported packet version
raise NotImplementedError("Unsupported key version: %s" % self.version)
return idx
def fill(self, d):
self._d = d
idx = 0
self.version, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx + 8], idx)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
if self.alg_pubkey in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
self.RSA_me_modn, idx = MPI.strcalc_mpi(d[idx:], idx)
elif ASYM_ELGAMAL_E == self.alg_pubkey:
self.ELGAMAL_gk_modp, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_myk_modp, idx = MPI.strcalc_mpi(d[idx:], idx)
else:
raise PGPValueError, "Unsupported public key algorithm. Received alg_pubkey->(%s)" % self.alg_pubkey
def fill(self, d):
self._d = d
idx = 0
self.version, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx+8], idx)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx)
if self.alg_pubkey in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
self.RSA_me_modn, idx = MPI.strcalc_mpi(d[idx:], idx)
elif ASYM_ELGAMAL_E == self.alg_pubkey:
self.ELGAMAL_gk_modp, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_myk_modp, idx = MPI.strcalc_mpi(d[idx:], idx)
else:
raise PGPValueError, "Unsupported public key algorithm. Received alg_pubkey->(%s)" % self.alg_pubkey
def test3():
"""Timeout test"""
SLEEP_TIME = 5
MPI.register_mpi()
#
# Fork the parent
#
fork = tfork2()
if fork.isChild:
#
# In child
#
print("in child")
fork.release()
time.sleep(1.1 * SLEEP_TIME)
print("child sending hello")
MPI.send_mpi_message(rank=0, message='hello')
#
# Exit the child
#
fork.exit()
#
# In parent
# ---------
# Check received message
#
print("parent doing sync")
fork.sync()
t0 = time.time()
print("parent trying to receive msg")
print 'recieved message=%s of length=%d' % MPI.receive_mpi_message(
rank=1, timeout=2 * SLEEP_TIME, message_size=100)
dt = time.time() - t0
print 'dt = %g, should be bigger than %g' % (dt, SLEEP_TIME)
#
# Wait for the child to terminate
#
fork.wait()
def create_PublicKeyEncryptedSessionKeyBody(*args, **kwords):
"""
"""
try:
kwords = args[0]
except IndexError:
pass
version = '\x03'
keyid = STN.hex2str(kwords['keyid'])
algorithm = STN.int2str(kwords['alg'])[0]
if kwords['alg'] in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
mpi_d = MPI.create_MPI(kwords['mpis'][0])._d
elif ASYM_ELGAMAL_E == kwords['alg']:
a_d = MPI.create_MPI(kwords['mpis'][0])._d
b_d = MPI.create_MPI(kwords['mpis'][1])._d
mpi_d = ''.join([a_d, b_d])
else:
raise PGPValueError, "Unsupported public key algorithm. Received alg->(%s)" % alg
_d = ''.join([version, keyid, algorithm, mpi_d])
return PublicKeyEncryptedSessionKeyBody(_d)
def create_PublicKeyEncryptedSessionKeyBody(*args, **kwords):
"""
"""
try:
kwords = args[0]
except IndexError:
pass
version = '\x03'
keyid = STN.hex2str(kwords['keyid'])
algorithm = STN.int2str(kwords['alg'])[0]
if kwords['alg'] in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
mpi_d = MPI.create_MPI(kwords['mpis'][0])._d
elif ASYM_ELGAMAL_E == kwords['alg']:
a_d = MPI.create_MPI(kwords['mpis'][0])._d
b_d = MPI.create_MPI(kwords['mpis'][1])._d
mpi_d = ''.join([a_d, b_d])
else:
raise PGPValueError, "Unsupported public key algorithm. Received alg->(%s)" % alg
_d = ''.join([version, keyid, algorithm, mpi_d])
return PublicKeyEncryptedSessionKeyBody(_d)
def test2():
"""Multi process test"""
MPI.register_mpi()
#
# Fork the parent
#
cpid = os.fork()
if (cpid == 0):
#
# In child
#
MPI.send_mpi_message(rank=0, message='hello')
#
# Terminate the child process
#
os._exit(0)
#
# Wait for the child to terminate
#
os.wait()
#
# read the message
#
print MPI.receive_mpi_message(rank=1, timeout=1000, message_size=100)
def run_scatter_reduce(self):
t0 = time()
self.data = self.comm.scatter(
self.chunks, root=0
) # Defines the data and the process that contains the data to be distributed
print(
'rank' + str(self.rank) + ' has data:' + str(self.data)
) # Print the datas available in each processes distributed by initial Processor
self.data_gather = self.comm.gather(
self.data, root=0) # Gather the data for a specific processor
for i in range(len(
self.data)): # Performs the calculation of the split data
self.data[i] = self.data[i] + 1
self.reduction_data = self.comm.reduce(
self.data, op=MPI.SUM,
root=0) # Reduce data to new array with calculation
self.comm.Barrier()
t = (time() - t0) * 1000
print(t)
if self.rank == 0:
print(self.data_gather)
print(self.reduction_data)
print(MPI.Get_version())
def __resolve_secmpi(self, idx):
d = self._d
# 1:RSA (Encrypt or Sign), 2:RSA Encrypt-Only, 3:RSA Sign-Only
if self.alg in [1, 2, 3]:
self.RSA_d, idx = MPI.strcalc_mpi(d[idx:], idx)
self.RSA_p, idx = MPI.strcalc_mpi(d[idx:], idx)
self.RSA_q, idx = MPI.strcalc_mpi(d[idx:], idx)
self.RSA_u, idx = MPI.strcalc_mpi(d[idx:], idx)
self._secmpi_d = self.RSA_d._d + self.RSA_p._d + self.RSA_q._d + self.RSA_u._d
# 17:DSA (Digital Signature Algorithm)
elif 17 == self.alg:
self.DSA_x, idx = MPI.strcalc_mpi(d[idx:], idx)
self._secmpi_d = self.DSA_x._d
# 16:Elgamal (Encrypt-Only), 20:Elgamal (Encrypt or Sign)
elif self.alg in [16, 20]:
self.ELGAMAL_x, idx = MPI.strcalc_mpi(d[idx:], idx)
self._secmpi_d = self.ELGAMAL_x._d
else:
self.err = (ValueError, "Unsupported key algorithm. Received alg->(%s)" % (str(self.alg)))
if 255 == self.s2k_usg:
self.chksum, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx)
else:
self.chksum = None
def fill(self, d):
self._d = d
idx = 0
__version_d = d[idx:idx + 1]
self.version, idx = STN.strcalc(STN.str2int, __version_d, idx)
if self.version in [2, 3, 4]:
__created_d = d[idx:idx + 4]
self.created, idx = STN.strcalc(STN.str2int, __created_d, idx)
if self.version in [2, 3]:
self.__expires_d = d[idx:idx + 2]
self.expires, idx = STN.strcalc(STN.str2int, self.__expires_d,
idx)
__alg_d = d[idx:idx + 1]
self.alg, idx = STN.strcalc(STN.str2int, __alg_d, idx)
# resolve MPIs
if self.alg in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]:
self.RSA_n, idx = MPI.strcalc_mpi(d[idx:], idx)
self.RSA_e, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.RSA_n._d + self.RSA_e._d
elif ASYM_DSA == self.alg:
self.DSA_p, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_q, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_g, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_y, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.DSA_p._d + self.DSA_q._d + self.DSA_g._d + self.DSA_y._d
elif self.alg in [ASYM_ELGAMAL_E, ASYM_ELGAMAL_EOS]:
self.ELGAMAL_p, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_g, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_y, idx = MPI.strcalc_mpi(d[idx:], idx)
self._mpi_d = self.ELGAMAL_p._d + self.ELGAMAL_g._d + self.ELGAMAL_y._d
else:
raise NotImplementedError(
"Unsupported key algorithm. Received alg->(%s)" % self.alg)
# set fingerprint
if self.version in [2, 3]:
integer_data = self.RSA_n._int_d + self.RSA_e._int_d
self.fingerprint = md5.new(integer_data).hexdigest().upper()
# see fingerprint/id notes in doc/NOTES.txt
self.id = STN.str2hex(self.RSA_n._int_d[-8:])
elif 4 == self.version:
f = ['\x99']
f_data = ''.join(
[__version_d, __created_d, __alg_d, self._mpi_d])
length = len(f_data)
hi = (chr((0xffff & length) >> 8)) # high order packet length
lo = (chr(0xff & length)) # low order packet length
f.append(hi + lo)
f.append(f_data)
self.fingerprint = sha.new(''.join(f)).hexdigest().upper()
# see fingerprint/id notes in doc/NOTES.txt
self.id = self.fingerprint[-16:]
else: # unsupported packet version
raise NotImplementedError("Unsupported key version: %s" %
self.version)
return idx
razmer = [c for c in range(3,14)]
for i in razmer:
A = matrix_generate(i)
b = vector_b_generate(i)
t1 = t.clock()
res,step,acc = MNS(A,b,eps)
t2 = t.clock()
time_mns.append(t2-t1)
result_mns.append(res)
steps_mns.append(step)
accuracy_mns.append(acc)
t1 = t.clock()
res,step,acc = MPI(A,b,eps)
t2 = t.clock()
time_mpi.append(t2-t1)
result_mpi.append(res)
steps_mpi.append(step)
accuracy_mpi.append(acc)
file_output(result_mpi,steps_mpi,time_mpi,accuracy_mpi,
result_mns,steps_mns,time_mns,accuracy_mns,params['output'])
if params['graph'] == 'yes' or params['graph'] == 'y':
start_plot(steps_mpi,time_mpi,steps_mns,time_mns,razmer)
def fill(self, d):
self._d = d
version_d = d[0]
self.version, idx = STN.strcalc(STN.str2int, d[0], 0)
if self.version in [2, 3]:
hash_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
self.type, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
self.created, idx = STN.strcalc(STN.str2int, d[idx:idx + 4], idx)
self.hashed_data = d[2:idx]
self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx + 8], idx)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1],
idx)
self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
self.hashed_subpkts = [] # dummy settings to make searches easier
self.unhashed_subpkts = [] #
elif 4 == self.version:
import struct
_type_d, idx = STN.strcalc(None, d[idx:idx + 1], idx)
self.type = STN.str2int(_type_d)
self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1],
idx)
self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx)
# hashed subpackets
subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 2], idx)
self.hashed_subpkts = self.__resolve_subpkts(d[idx:idx +
subpkts_len])
# hashed data & trailer - should '>i' ever return more than 4 chars?
hashed_data = d[0:idx + subpkts_len]
bigend = struct.pack('>i', len(hashed_data))[-4:]
self.hashed_data = ''.join(
[hashed_data, version_d, '\xff', bigend])
idx = idx + subpkts_len
# unhashed subpackets
subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 2], idx)
self.unhashed_subpkts = self.__resolve_subpkts(d[idx:idx +
subpkts_len])
idx = idx + subpkts_len
# attribute convenience
self.keyid = self.__set_subpkt_attr(SIGSUB_SIGNERID) or ''
self.created = self.__set_subpkt_attr(SIGSUB_CREATED) or 0
else:
raise PGPValueError(
"Unsupported signature version. Received->(%s)" %
str(self.version))
self.hash_frag, idx = STN.strcalc(None, d[idx:idx + 2], idx)
if self.alg_pubkey in [ASYM_RSA_S, ASYM_RSA_EOS]:
self.RSA, idx = MPI.strcalc_mpi(d[idx:], idx)
elif ASYM_DSA == self.alg_pubkey:
self.DSA_r, idx = MPI.strcalc_mpi(d[idx:], idx)
self.DSA_s, idx = MPI.strcalc_mpi(d[idx:], idx)
elif self.alg_pubkey in [ASYM_ELGAMAL_EOS]:
self.ELGAMAL_a, idx = MPI.strcalc_mpi(d[idx:], idx)
self.ELGAMAL_b, idx = MPI.strcalc_mpi(d[idx:], idx)
else:
raise PGPValueError("Unsupported public-key algorithm (%d)." %
self.alg_pubkey)
import cv2
import numpy as np
from collections import deque
import os
import sys
import numpy as np
import mpi4py import MPI
import time
comm = MPI.COMM_WORLD
size - comm.Get_size()
rank - comm.Get_rank()
name - MPI.Get_processor_name()
os.environ['SDL_VIDEO_WINDOW_POS'] = "0,0"
os.environ['DISPLAY'] = '0, 0'
comm.Barrier
width = 640
height = 480
cap = cv2.VideoCapture(0)
cap.set(3, width)
cap.set(4, height)
video = cv2.VideoCapture("roadV.mov")
video1 = cv2.VideoCapture("roadO.mov")
import sys
import System
import clr
clr.AddReference("MPI")
import MPI
args = System.Environment.GetCommandLineArgs()
argsref = clr.Reference[System.Array[str]](args)
env = MPI.Environment(argsref)
destHostname = ""
comm = MPI.Communicator.world
if comm.Rank == 0:
print "Rank 0 is alive and running on " + MPI.Environment.ProcessorName
for dest in range(1, comm.Size):
print "Pinging process with rank " + str(dest) + "..."
comm.Send[str]("Ping!", dest, 0)
destHostname = comm.Receive[str].Overloads[(int, int)](dest, 1)
print " Pong!"
print " Rank " + str(dest) + " is alive and running on " + str(
destHostname)
else:
destHostname = comm.Receive[str].Overloads[(int, int)](0, 0)
comm.Send[str](str(MPI.Environment.ProcessorName), 0, 1)
env.Dispose()
def test1():
"""Basic Test"""
MPI.register_mpi()
MPI.send_mpi_message(rank=0, message='hello')
print MPI.receive_mpi_message(rank=0, timeout=1000, message_size=100)
