rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
>>> check._match(host='my.example.com', certHost='DNS:m*.example.com', subjectAltName=True) | >>> check._splitSubjectAltName(host='my.example.com', subjectAltName='DNS:m*.example.com') | def _match(self, host, certHost, subjectAltName=False): """ >>> check = Checker() >>> check._match(host='my.example.com', certHost='DNS:my.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certHost='DNS:*.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certH... |
>>> check._match(host='my.example.com', certHost='DNS:m*ample.com', subjectAltName=True) | >>> check._splitSubjectAltName(host='my.example.com', subjectAltName='DNS:m*ample.com') | def _match(self, host, certHost, subjectAltName=False): """ >>> check = Checker() >>> check._match(host='my.example.com', certHost='DNS:my.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certHost='DNS:*.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certH... |
if subjectAltName: if certHost[:4] != 'dns:': return False certHost = certHost[4:] | def _match(self, host, certHost, subjectAltName=False): """ >>> check = Checker() >>> check._match(host='my.example.com', certHost='DNS:my.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certHost='DNS:*.example.com', subjectAltName=True) True >>> check._match(host='my.example.com', certH... | |
h = httpslib.HTTPSConnection('127.0.0.1', 9443, ssl_context=ctx) | h = httpslib.HTTPSConnection('localhost', 19443, ssl_context=ctx) | def test_httpslib(): ctx = SSL.Context('sslv23') ctx.load_cert_chain('client.pem') ctx.load_verify_locations('ca.pem', '') ctx.set_verify(SSL.verify_peer, 10) ctx.set_info_callback() h = httpslib.HTTPSConnection('127.0.0.1', 9443, ssl_context=ctx) h.set_debuglevel(1) h.putrequest('GET', '/') h.putheader('Accept', 'text... |
def handle_connect(self): pass | def __init__(self, conn): SSL.ssl_dispatcher.__init__(self, conn) self.rc = 1 self.wc = 1 self.peer = None | def handle_connect(self): pass |
def handle_close(self): self.close() | def handle_connect(self): pass | def handle_close(self): self.close() |
def writeable(self): return len(self.buffer) > 0 | def handle_close(self): self.close() def writeable(self): time.sleep(1) return len(self.buffer) > 0 | def writeable(self): return len(self.buffer) > 0 |
def handle_write(self): n=self.send(self.buffer) if n==-1: pass elif n==0: self.handle_close() else: self.buffer=self.buffer[n:] | def handle_write(self): self.wc = self.wc + 1 if self.peer is None: self.peer = self.get_peer_cert() if self.peer is not None: print 'wc =', self.wc print self.peer.get_subject() try: n=self.send(self.buffer) if n == -1: pass elif n == 0: self.handle_close() else: self.buffer=self.buffer[n:] except: self.close() | def handle_write(self): n=self.send(self.buffer) if n==-1: pass elif n==0: self.handle_close() else: self.buffer=self.buffer[n:] |
def handle_read(self): blob=self.recv() if blob is None: pass elif blob=='': self.handle_close() else: self.buffer = self.buffer + blob | def handle_read(self): self.rc = self.rc + 1 if self.peer is None: self.peer = self.get_peer_cert() if self.peer is not None: print 'rc =', self.rc print self.peer.get_subject() try: blob=self.recv() if blob is None: pass elif blob == '': self.handle_close() else: self.buffer = self.buffer + blob except: self.close() | def handle_read(self): blob=self.recv() if blob is None: pass elif blob=='': self.handle_close() else: self.buffer = self.buffer + blob |
def __init__(self, addr, port, ssl_context): asyncore.dispatcher.__init__(self) self.create_socket(ssl_context) self.set_reuse_addr() self.socket.setblocking(0) self.bind((addr, port)) self.listen(5) def handle_accept(self): sock, addr=self.socket.accept() self.channel_class(sock) | def __init__(self, addr, port, ssl_context): SSL.ssl_dispatcher.__init__(self) self.create_socket(ssl_context) self.set_reuse_addr() self.socket.setblocking(0) self.bind((addr, port)) self.listen(5) self.ssl_ctx=ssl_context def handle_accept(self): try: sock, addr = self.socket.accept() self.channel_class(sock) except... | def __init__(self, addr, port, ssl_context): asyncore.dispatcher.__init__(self) self.create_socket(ssl_context) self.set_reuse_addr() self.socket.setblocking(0) self.bind((addr, port)) self.listen(5) |
ctx=SSL.Context('sslv23') ctx.load_cert('server.pem') ssl_echo_server('', 9999, ctx) asyncore.loop() | Rand.load_file('../randpool.dat', -1) ctx=echod_lib.init_context('sslv23', 'server.pem', 'ca.pem', \ SSL.verify_peer | SSL.verify_fail_if_no_peer_cert) ctx.set_tmp_dh('dh1024.pem') ssl_echo_server('', 9999, ctx) asyncore.loop() Rand.save_file('../randpool.dat') | def writeable(self): return 0 |
return '' | return 0 | def send(self, data): try: result = self.socket._write_nbio(data) if result <= 0: return 0 else: self.server.bytes_out.increment(result) return result except SSL.SSLError, why: self.close() self.log_info('send: closing channel %s %s' % (repr(self), why)) return '' |
from medusa import asyncore | import asyncore | def log_info(self, message, type='info'): if message[:14]=='adding channel' or \ message[:15]=='closing channel' or \ message == 'Computing default hostname': LOG('ZServer', BLATHER, message) else: LOG('ZServer', severity[type], message) |
import fcntl, FCNTL FCNTL.F_SETFD; FCNTL.FD_CLOEXEC | import fcntl try: from fcntl import F_SETFD, FD_CLOEXEC except ImportError: from FCNTL import F_SETFD, FD_CLOEXEC | def log_info(self, message, type='info'): if message[:14]=='adding channel' or \ message[:15]=='closing channel' or \ message == 'Computing default hostname': LOG('ZServer', BLATHER, message) else: LOG('ZServer', severity[type], message) |
try: fcntl.fcntl(sock.fileno(), FCNTL.F_SETFD, FCNTL.FD_CLOEXEC) | try: fcntl.fcntl(sock.fileno(), F_SETFD, FD_CLOEXEC) | def requestCloseOnExec(sock): try: fcntl.fcntl(sock.fileno(), FCNTL.F_SETFD, FCNTL.FD_CLOEXEC) except: pass |
from medusa import resolver, logger, asyncore | import asyncore from medusa import resolver, logger | def requestCloseOnExec(sock): pass |
self.shutup = 1 https_server.__init__(self, ip, port, ssl_ctx, resolver, logger_object) self.ssl_ctx = ssl_ctx self.shutup = 0 self.log_info('(%s) HTTPS server started at %s\n' '\tHostname: %s\n\tPort: %d' % ( self.SERVER_IDENT, time.ctime(time.time()), self.server_name, self.server_port )) | http_server.http_server.__init__(self, ip, port, resolver, logger_object) self.ssl_ctx=ssl_ctx | def __init__(self, ip, port, ssl_ctx, resolver=None, logger_object=None): self.shutup = 1 https_server.__init__(self, ip, port, ssl_ctx, resolver, logger_object) self.ssl_ctx = ssl_ctx self.shutup = 0 self.log_info('(%s) HTTPS server started at %s\n' '\tHostname: %s\n\tPort: %d' % ( self.SERVER_IDENT, time.ctime(time.t... |
def log_info(self, message, type='info'): if self.shutup: return dispatcher.log_info(self, message, type) | def handle_accept(self): self.total_clients.increment() try: conn, addr = self.accept() except socket.error: sys.stderr.write ('warning: server accept() threw an exception\n') return | def log_info(self, message, type='info'): if self.shutup: return dispatcher.log_info(self, message, type) |
def readable(self): return self.accepting and \ len(asyncore.socket_map) < CONNECTION_LIMIT | try: ssl_conn=SSL.Connection(self.ssl_ctx, conn) ssl_conn._setup_ssl(addr) ssl_conn.accept_ssl() self.channel_class(self, ssl_conn, addr) except SSL.SSLError: pass | def readable(self): return self.accepting and \ len(asyncore.socket_map) < CONNECTION_LIMIT |
libraries = ['ssleay32', 'libeay32'] | libraries = ['ssl32', 'eay32'] | def swig_sources (self, sources): """Walk the list of source files in 'sources', looking for SWIG interface (.i) files. Run SWIG on all that are found, and return a modified 'sources' list with SWIG source files replaced by the generated C (or C++) files. """ new_sources = [] swig_sources = [] swig_targets = {} # X... |
extra_compile_args = [ "-DTHREADING" ] | def swig_sources (self, sources): | |
extra_compile_args = extra_compile_args | extra_compile_args = ['-DTHREADING', '-DSWIG_COBJECT_PYTHON'] | def swig_sources (self, sources): |
out = BIO.openfile('p7.clear', 'w') | out = BIO.openfile('clear.p7', 'w') | def sign(): print 'test sign & save...', buf = makebuf() s = SMIME.SMIME() s.load_key('client.pem') p7 = s.sign(buf) out = BIO.openfile('p7.clear', 'w') out.write('To: ngps@post1.com\n') out.write('From: m2crypto@m2crypto.org\n') out.write('Subject: testing\n') buf = makebuf() # Recreate buf, because sign() has consume... |
out = BIO.openfile('p7.opaque', 'w') | out = BIO.openfile('opaque.p7', 'w') | def sign(): print 'test sign & save...', buf = makebuf() s = SMIME.SMIME() s.load_key('client.pem') p7 = s.sign(buf) out = BIO.openfile('p7.clear', 'w') out.write('To: ngps@post1.com\n') out.write('From: m2crypto@m2crypto.org\n') out.write('Subject: testing\n') buf = makebuf() # Recreate buf, because sign() has consume... |
p7, data = SMIME.load_pkcs7('p7.clear') | p7, data = SMIME.load_pkcs7('clear.p7') | def verify_clear(): print 'test load & verify clear...', s = SMIME.SMIME() x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.load_pkcs7('p7.clear') v = s.verify(p7) if v == ptxt: print 'ok' el... |
if v == ptxt: | if v: | def verify_clear(): print 'test load & verify clear...', s = SMIME.SMIME() x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.load_pkcs7('p7.clear') v = s.verify(p7) if v == ptxt: print 'ok' el... |
p7, data = SMIME.load_pkcs7('p7.opaque') | p7, data = SMIME.load_pkcs7('opaque.p7') | def verify_opaque(): print 'test load & verify opaque...', s = SMIME.SMIME() x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.load_pkcs7('p7.opaque') v = s.verify(p7, data) if v == ptxt: prin... |
if v == ptxt: | if v: | def verify_opaque(): print 'test load & verify opaque...', s = SMIME.SMIME() x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.load_pkcs7('p7.opaque') v = s.verify(p7, data) if v == ptxt: prin... |
p7 = s.sign(buf) bio = BIO.MemoryBuffer() s.write(bio, p7, buf) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) | def sv(): print 'test sign/verify...', buf = makebuf() s = SMIME.SMIME() # Load a private key. s.load_key('client.pem') # Load signer cert(s). x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) # Sign. p7 = s.sign(buf, SMIME.PKCS7_DETACHED) #p7 = s.sign(buf) # Construct ve... | |
p7 = s.sign(buf, SMIME.PKCS7_DETACHED) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) | def sv(): print 'test sign/verify...', buf = makebuf() s = SMIME.SMIME() # Load a private key. s.load_key('client.pem') # Load signer cert(s). x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) # Sign. p7 = s.sign(buf, SMIME.PKCS7_DETACHED) #p7 = s.sign(buf) # Construct ve... | |
buf = makebuf() v = s.verify(p7, buf, SMIME.PKCS7_DETACHED) | p7, buf = SMIME.load_pkcs7_bio(bio) v = s.verify(p7, flags=SMIME.PKCS7_DETACHED) | def sv(): print 'test sign/verify...', buf = makebuf() s = SMIME.SMIME() # Load a private key. s.load_key('client.pem') # Load signer cert(s). x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) # Sign. p7 = s.sign(buf, SMIME.PKCS7_DETACHED) #p7 = s.sign(buf) # Construct ve... |
if data == ptxt: | if data: | def ed(): print 'test encrypt/decrypt...', buf = makebuf() s = SMIME.SMIME() # Load target cert to encrypt to. x509 = X509.load_cert('client.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) # Add a cipher. s.set_cipher(SMIME.Cipher('bf_cbc')) # Encrypt. p7 = s.encrypt(buf) # Load target's private key... |
m2.ssl_set_client_CA_list(self.ssl, cafile) | m2.ssl_set_client_CA_list_from_file(self.ssl, cafile) | def set_client_CA_list_from_file(self, cafile): m2.ssl_set_client_CA_list(self.ssl, cafile) |
def pbsz(self): """Send PBSZ for secure data connection.""" | def prot_p(self): """Set up secure data connection.""" | def pbsz(self): """Send PBSZ for secure data connection.""" self.voidcmd('PBSZ 0') |
def prot_p(self): """Send PROT P for secure data connection.""" | def pbsz(self): """Send PBSZ for secure data connection.""" self.voidcmd('PBSZ 0') | |
def _serverPostConnectionCheck(peerX509, expectedHost): | def _serverPostConnectionCheck(*args, **kw): | def _serverPostConnectionCheck(peerX509, expectedHost): return 1 |
check = getattr(self, 'postConnectionCheck', Connection.serverPostConnectionCheck) | check = getattr(self, 'postConnectionCheck', self.serverPostConnectionCheck) | def accept(self): """Accept an SSL connection. The return value is a pair (ssl, addr) where ssl is a new SSL connection object and addr is the address bound to the the other end of the SSL connection.""" sock, addr = self.socket.accept() ssl = Connection(self.ctx, sock) ssl.addr = addr ssl.setup_ssl() ssl.set_accept_st... |
if not check(self.get_peer_cert(), self.addr[0]): | if not check(self.get_peer_cert(), ssl.addr[0]): | def accept(self): """Accept an SSL connection. The return value is a pair (ssl, addr) where ssl is a new SSL connection object and addr is the address bound to the the other end of the SSL connection.""" sock, addr = self.socket.accept() ssl = Connection(self.ctx, sock) ssl.addr = addr ssl.setup_ssl() ssl.set_accept_st... |
check = getattr(self, 'postConnectionCheck', Connection.clientPostConnectionCheck) | check = getattr(self, 'postConnectionCheck', self.clientPostConnectionCheck) | def connect(self, addr): self.socket.connect(addr) self.addr = addr self.setup_ssl() self.set_connect_state() ret = self.connect_ssl() check = getattr(self, 'postConnectionCheck', Connection.clientPostConnectionCheck) if check is not None: if not check(self.get_peer_cert(), self.addr[0]): raise Checker.SSLVerificationE... |
self.send = self.write = Connection._write_bio self.recv = self.read = Connection._read_bio | self.send = self.write = _write_bio self.recv = self.read = _read_bio | def setblocking(self, mode): """Set this connection's underlying socket to _mode_.""" self.socket.setblocking(mode) if mode: self.send = self.write = Connection._write_bio self.recv = self.read = Connection._read_bio else: self.send = self.write = Connection._write_nbio self.recv = self.read = Connection._read_nbio |
self.send = self.write = Connection._write_nbio self.recv = self.read = Connection._read_nbio | self.send = self.write = _write_nbio self.recv = self.read = _read_nbio | def setblocking(self, mode): """Set this connection's underlying socket to _mode_.""" self.socket.setblocking(mode) if mode: self.send = self.write = Connection._write_bio self.recv = self.read = Connection._read_bio else: self.send = self.write = Connection._write_nbio self.recv = self.read = Connection._read_nbio |
10) | 10, verify_callback) | def setup_server_ctx(): ctx = SSL.Context('sslv23') if ctx.load_verify_locations('ca.pem') != 1: print "***No CA file" #if ctx.set_default_verify_paths() != 1: # print "***No default verify paths" ctx.load_cert_chain('server.pem') ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 10)#, verify_callbac... |
def post_connection_check(conn): cert = conn.get_peer_cert() if cert is None: | def post_connection_check(peerX509, expectedHost): if peerX509 is None: | def post_connection_check(conn): cert = conn.get_peer_cert() if cert is None: print "***No peer certificate" # Not sure if we can do any other checks |
if 1: f = open('smime_test.txt', 'wb') f.write(signedEncrypted.read()) f.close() p7, data = SMIME.smime_load_pkcs7('smime_test.txt') import os os.remove('smime_test.txt') else: p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) | p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) | def check_signEncryptDecryptVerify(self): # sign buf = BIO.MemoryBuffer(self.cleartext) s = SMIME.SMIME() s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) # encrypt x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) s.set_cipher(SMIME.Cipher('des_ede3_cbc')) t... |
ret = m2.ssl_accept(self.ssl) if not ret: raise Err.SSLError(Err.get_error_code(), addr) | m2.ssl_accept(self.ssl) | def accept_ssl(self, addr): ret = m2.ssl_accept(self.ssl) if not ret: raise Err.SSLError(Err.get_error_code(), addr) |
def connect(self, addr): | def _old_connect(self, addr): | def connect(self, addr): self.socket.connect(addr) self._setup_ssl(addr) ret = m2.ssl_connect(self.ssl) if not ret: raise Err.SSLError(Err.get_error_code(), addr) |
return m2.bio_write(self.sslbio, data) | return m2.ssl_write(self.ssl, data) | def _write_bio(self, data): return m2.bio_write(self.sslbio, data) |
return m2.bio_read(self.sslbio, size) | return m2.ssl_read(self.ssl, size) | def _read_bio(self, size=4096): if size<=0: raise ValueError, 'size <= 0' return m2.bio_read(self.sslbio, size) |
send = write =_write_bio recv = read =_read_bio def _write_nbio(self, data): (n, err)=m2.ssl_write_nbio(self.ssl, data) if n==-1: if err==m2.ssl_error_zero_return: return 0 elif err==m2.ssl_error_syscall: raise Err.SSLError(n, self.socket.getpeername()) else: return -1 else: if n==0: return -1 else: return n def _rea... | send = write = _write_nbio = _write_bio recv = read = _read_nbio = _read_bio | def _read_bio(self, size=4096): if size<=0: raise ValueError, 'size <= 0' return m2.bio_read(self.sslbio, size) |
if mode==0: self.recv=self.read=self._read_nbio self.send=self.write=self._write_nbio else: self.recv=self.read=self._read_bio self.send=self.write=self._write_bio | def setblocking(self, mode): self.socket.setblocking(mode) if mode==0: self.recv=self.read=self._read_nbio self.send=self.write=self._write_nbio else: self.recv=self.read=self._read_bio self.send=self.write=self._write_bio | |
def get_error(self, err): return SSL_error[m2.ssl_get_error(self.ssl, err)] | def get_error(self, err): return SSL_error[m2.ssl_get_error(self.ssl, err)] | |
return X509.X509(c) | return X509.X509(c, 1) | def get_peer_cert(self): c=m2.ssl_get_peer_cert(self.ssl) if c is None: return None return X509.X509(c) |
socket2 = self.socket.makefile(mode, bufsize) sockbio = m2.bio_new_socket(socket2.fileno(), 1) ssl = m2.ssl_dup(self.ssl) m2.ssl_set_bio(ssl, sockbio, sockbio) | def _makefile(self, mode='r', bufsize=1024): # XXX doesn't work socket2 = self.socket.makefile(mode, bufsize) sockbio = m2.bio_new_socket(socket2.fileno(), 1) ssl = m2.ssl_dup(self.ssl) m2.ssl_set_bio(ssl, sockbio, sockbio) sslbio = m2.bio_dup_chain(self.sslbio) #m2.bio_set_ssl(sslbio, ssl, 0) m2.bio_push(sslbio, sockb... | |
m2.bio_push(sslbio, sockbio) | def _makefile(self, mode='r', bufsize=1024): # XXX doesn't work socket2 = self.socket.makefile(mode, bufsize) sockbio = m2.bio_new_socket(socket2.fileno(), 1) ssl = m2.ssl_dup(self.ssl) m2.ssl_set_bio(ssl, sockbio, sockbio) sslbio = m2.bio_dup_chain(self.sslbio) #m2.bio_set_ssl(sslbio, ssl, 0) m2.bio_push(sslbio, sockb... | |
def check_mkcacert(self): | def mkcacert(self): | def check_mkcacert(self): req, pk = self.mkreq(512, ca=1) pkey = req.get_pubkey() sub = req.get_subject() cert = X509.X509() cert.set_serial_number(1) cert.set_version(2) cert.set_subject(sub) t = long(time.time()) + time.timezone now = ASN1.ASN1_UTCTIME() now.set_time(t) nowPlusYear = ASN1.ASN1_UTCTIME() nowPlusYear.s... |
cert.set_pubkey(pkey) cert.set_pubkey(cert.get_pubkey()) | cert.set_pubkey(pkey) | def check_mkcacert(self): req, pk = self.mkreq(512, ca=1) pkey = req.get_pubkey() sub = req.get_subject() cert = X509.X509() cert.set_serial_number(1) cert.set_version(2) cert.set_subject(sub) t = long(time.time()) + time.timezone now = ASN1.ASN1_UTCTIME() now.set_time(t) nowPlusYear = ASN1.ASN1_UTCTIME() nowPlusYear.s... |
return cert, pk, pkey def check_mkcacert(self): cacert, pk, pkey = self.mkcacert() assert cacert.verify(pkey) def check_mkproxycert(self): cacert, pk1, pkey = self.mkcacert() end_entity_cert_req, pk2 = self.mkreq(512) end_entity_cert = self.make_eecert(cacert) end_entity_cert.set_subject(end_entity_cert_req.get_subj... | def check_mkcacert(self): req, pk = self.mkreq(512, ca=1) pkey = req.get_pubkey() sub = req.get_subject() cert = X509.X509() cert.set_serial_number(1) cert.set_version(2) cert.set_subject(sub) t = long(time.time()) + time.timezone now = ASN1.ASN1_UTCTIME() now.set_time(t) nowPlusYear = ASN1.ASN1_UTCTIME() nowPlusYear.s... | |
if (sys.version[:3] == '2.2' and sys.version_info[2] > 1) or (sys.version[:3] == '2.3'): | if sys.version_info[:3] > (2, 2, 1): | def close(self): # This kludges around line 545 of httplib.py, # which closes the connection in this object; # the connection remains open in the response # object. # # M2Crypto doesn't close-here-keep-open-there, # so, in effect, we don't close until the whole # business is over and gc kicks in. # # Long-running calle... |
buf = buf.strip() assert buf[-len('-----END PKCS7-----'):] == '-----END PKCS7-----', buf[-len('-----END PKCS7-----'):] | def check_1_sign(self): global signature, signature2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) assert len(buf) == 0 assert p7.type() == SMIME.PKCS7_SIGNED, p7.type() assert isinstance(p7, SMIME.PKCS7), p7 #assert p7.get0_signers() out = BIO.MemoryBu... | |
s.write(out, p7, BIO.MemoryBuffer(cleartext)) signature = out s.write(out, p7, BIO.MemoryBuffer(cleartext)) signature2 = out def check_2_verify(self): | s.write(out, p7, BIO.MemoryBuffer(self.cleartext)) return out def check_verify(self): | def check_1_sign(self): global signature, signature2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) assert len(buf) == 0 assert p7.type() == SMIME.PKCS7_SIGNED, p7.type() assert isinstance(p7, SMIME.PKCS7), p7 #assert p7.get0_signers() out = BIO.MemoryBu... |
p7, data = SMIME.smime_load_pkcs7_bio(signature) assert data.read() == cleartext | p7, data = SMIME.smime_load_pkcs7_bio(self.signature) assert data.read() == self.cleartext | def check_2_verify(self): s = SMIME.SMIME() x509 = X509.load_cert('signer.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.smime_load_pkcs7_bio(signature) assert data.read() == cleartext assert isinstance(p7, SMIME.PKC... |
assert v == cleartext | assert v == self.cleartext | def check_2_verify(self): s = SMIME.SMIME() x509 = X509.load_cert('signer.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('ca.pem') s.set_x509_store(st) p7, data = SMIME.smime_load_pkcs7_bio(signature) assert data.read() == cleartext assert isinstance(p7, SMIME.PKC... |
def _check_2_verifyBad(self): | def check_verifyBad(self): | def _check_2_verifyBad(self): s = SMIME.SMIME() x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('recipient.pem') s.set_x509_store(st) p7, data = SMIME.smime_load_pkcs7_bio(signature2) assert data.read() == cleartext assert isinstanc... |
p7, data = SMIME.smime_load_pkcs7_bio(signature2) assert data.read() == cleartext | p7, data = SMIME.smime_load_pkcs7_bio(self.signature) assert data.read() == self.cleartext | def _check_2_verifyBad(self): s = SMIME.SMIME() x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('recipient.pem') s.set_x509_store(st) p7, data = SMIME.smime_load_pkcs7_bio(signature2) assert data.read() == cleartext assert isinstanc... |
self.assertRaises(SMIME.SMIME_Error, s.verify, p7) | self.assertRaises(SMIME.PKCS7_Error, s.verify, p7) | def _check_2_verifyBad(self): s = SMIME.SMIME() x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Store() st.load_info('recipient.pem') s.set_x509_store(st) p7, data = SMIME.smime_load_pkcs7_bio(signature2) assert data.read() == cleartext assert isinstanc... |
def check_3_encrypt(self): | def check_encrypt(self): | def check_3_encrypt(self): global encrypted, encrypted2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() |
buf = BIO.MemoryBuffer(cleartext) | buf = BIO.MemoryBuffer(self.cleartext) | def check_3_encrypt(self): global encrypted, encrypted2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() |
buf = buf.strip() assert buf[-len('-----END PKCS7-----'):] == '-----END PKCS7-----' | def check_3_encrypt(self): global encrypted, encrypted2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() | |
encrypted = out s.write(out, p7) encrypted2 = out def check_4_decrypt(self): | return out def check_decrypt(self): | def check_3_encrypt(self): global encrypted, encrypted2 buf = BIO.MemoryBuffer(cleartext) s = SMIME.SMIME() |
p7, data = SMIME.smime_load_pkcs7_bio(encrypted) | p7, data = SMIME.smime_load_pkcs7_bio(self.encrypted) | def check_4_decrypt(self): s = SMIME.SMIME() |
assert out == cleartext | assert out == self.cleartext | def check_4_decrypt(self): s = SMIME.SMIME() |
def _check_4_decryptBad(self): | def check_decryptBad(self): | def _check_4_decryptBad(self): s = SMIME.SMIME() |
p7, data = SMIME.smime_load_pkcs7_bio(encrypted2) | p7, data = SMIME.smime_load_pkcs7_bio(self.encrypted) | def _check_4_decryptBad(self): s = SMIME.SMIME() |
def check_5_signEncrypt(self): global signedEncrypted | def check_signEncrypt(self): | def check_5_signEncrypt(self): global signedEncrypted s = SMIME.SMIME() buf = BIO.MemoryBuffer(cleartext) s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) s.set_cipher(SMIME.Cipher('des_ede3_cbc')) tmp = BI... |
buf = BIO.MemoryBuffer(cleartext) | buf = BIO.MemoryBuffer(self.cleartext) | def check_5_signEncrypt(self): global signedEncrypted s = SMIME.SMIME() buf = BIO.MemoryBuffer(cleartext) s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) s.set_cipher(SMIME.Cipher('des_ede3_cbc')) tmp = BI... |
signedEncrypted = out def _check_6_decryptVerify(self): | def _check_decryptVerify(self): | def check_5_signEncrypt(self): global signedEncrypted s = SMIME.SMIME() buf = BIO.MemoryBuffer(cleartext) s.load_key('signer_key.pem', 'signer.pem') p7 = s.sign(buf) x509 = X509.load_cert('recipient.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) s.set_cipher(SMIME.Cipher('des_ede3_cbc')) tmp = BI... |
p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) | p7, data = SMIME.smime_load_pkcs7_bio(self.signedEncrypted) | def _check_6_decryptVerify(self): s = SMIME.SMIME() s.load_key('recipient_key.pem', 'recipient.pem') # XXX Bug not enough data? p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) out = s.decrypt(p7) x509 = X509.load_cert('signer.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Sto... |
st.load_info('signer.pem') | st.load_info('ca.pem') | def _check_6_decryptVerify(self): s = SMIME.SMIME() s.load_key('recipient_key.pem', 'recipient.pem') # XXX Bug not enough data? p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) out = s.decrypt(p7) x509 = X509.load_cert('signer.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Sto... |
assert v == cleartext | assert v == self.cleartext | def _check_6_decryptVerify(self): s = SMIME.SMIME() s.load_key('recipient_key.pem', 'recipient.pem') # XXX Bug not enough data? p7, data = SMIME.smime_load_pkcs7_bio(signedEncrypted) out = s.decrypt(p7) x509 = X509.load_cert('signer.pem') sk = X509.X509_Stack() sk.push(x509) s.set_x509_stack(sk) st = X509.X509_Sto... |
host = None | host = self.transport.getPeer().host | def _check(self): if debug: print 'TwistedProtocolWrapper._check' if not self.checked and m2.ssl_is_init_finished(self.ssl): x = m2.ssl_get_peer_cert(self.ssl) if x: x509 = X509.X509(x, 1) else: x509 = None if self.isClient: host = self.transport.addr[0] else: host = None if not self.postConnectionCheck(x509, host): r... |
if getattr(m2, cipher, None) is None: | proto = getattr(m2, cipher, None) if proto is None: | def save_key_bio(self, bio, cipher='aes_128_cbc', callback=util.passphrase_callback): """ Save the key pair to the M2Crypto.BIO object 'bio' in PEM format. |
return m2.pkey_write_pem(self.pkey, bio._ptr(), cipher, callback) | return m2.pkey_write_pem(self.pkey, bio._ptr(), proto(), callback) | def save_key_bio(self, bio, cipher='aes_128_cbc', callback=util.passphrase_callback): """ Save the key pair to the M2Crypto.BIO object 'bio' in PEM format. |
self.items = items | self._items = items | def __init__(self, items, sort_on): self.items = items self.sort_on = sort_on # tuple of (column name, reversed) pairs self.cache = [] self.iter = None |
self.cache = [] self.iter = None | self._cache = [] self._iterable = None @property def items(self): if getattr(self._items, '__getitem__', None) is not None: return self._items else: return self._iter() def _iter(self): ix = 0 cache = self._cache iterable = self._iterable if iterable is None: iterable = self._iterable = iter(self._items) while True:... | def __init__(self, items, sort_on): self.items = items self.sort_on = sort_on # tuple of (column name, reversed) pairs self.cache = [] self.iter = None |
stride = slice.stride | stride = slice.step | def __getitem__(self, key): if isinstance(key, slice): start = slice.start stop = slice.stop stride = slice.stride else: start = stop = key stride = 1 |
return self.items.__getitem__(key) | return items.__getitem__(key) | def __getitem__(self, key): if isinstance(key, slice): start = slice.start stop = slice.stop stride = slice.stride else: start = stop = key stride = 1 |
res = [] | def __getitem__(self, key): if isinstance(key, slice): start = slice.start stop = slice.stop stride = slice.stride else: start = stop = key stride = 1 | |
ix_offset = len(self.cache) for ix, val in enumerate(self.items): ix += ix_offset self.cache.append(val) | res = [] for ix, val in enumerate(items): | def __getitem__(self, key): if isinstance(key, slice): start = slice.start stop = slice.stop stride = slice.stride else: start = stop = key stride = 1 |
self.items, self.formatter, start, stop, self.sorters[1:]) | items, self.formatter, start, stop, self.sorters[1:]) | def __getitem__(self, key): if isinstance(key, slice): start = slice.start stop = slice.stop stride = slice.stride else: start = stop = key stride = 1 |
iter(self).next() | iter(self.items).next() | def __nonzero__(self): try: iter(self).next() except StopIteration: return False return True |
if self.iter is None: if not self.sort_on: self.iter = iter(self.items) else: self.iter = iter(self.sorters[0]( self.items, self.formatter, 0, None, self.sorters[1:])) ix = 0 cache = self.cache while True: try: yield cache[ix] except IndexError: try: next = self.iter.next() except StopIteration: break cache.append(next... | if not self.sort_on: return iter(self.items) else: sorters = self.sorters return iter(sorters[0]( self.items, self.formatter, 0, None, sorters[1:])) | def __iter__(self): if self.iter is None: if not self.sort_on: self.iter = iter(self.items) else: self.iter = iter(self.sorters[0]( self.items, self.formatter, 0, None, self.sorters[1:])) ix = 0 cache = self.cache while True: try: yield cache[ix] except IndexError: try: next = self.iter.next() except StopIteration: bre... |
return template % locals() | return template % options | def _addSortUi(self, header, column): columnName = column.name resource_path = component.getAdapter(self.request, name='zc.table')() if (interfaces.IColumnSortedItems.providedBy(self.items) and self.items.sort_on): sortColumnName, sortReversed = self.items.sort_on[0] else: sortColumnName = sortReversed = None if column... |
'wget' : 'wget: brąkujacy URL\r\nUżycie: wget [OPCJE]... [URL]...\ \r\nPolecenie `wget --help wyświetli więcej opcji.\r\n', | 'wget' : 'wget: b', | def pwd(shell, args): return shell.cwd + '\r\n' |
usemem = "%s/usemem -m %d" % (self.srcdir, kilobytes / 1024) Popen(usemem, shell=True) Popen(usemem, shell=True) | pid = [None, None] for i in (0,1): usemem = os.path.join(self.srcdir, 'usemem') args = ('usemem', '-N', '-m', '%d' % (kilobytes / 1024)) pid[i] = os.spawnv(os.P_NOWAIT, usemem, args) | def execute(self, testdir = None): if not testdir: testdir = self.tmpdir os.chdir(testdir) file = os.path.join(testdir, 'foo') # Want to use twice total memsize kilobytes = 2 * memtotal() |
Popen(cmd, shell=True) | os.system(cmd) | def execute(self, testdir = None): if not testdir: testdir = self.tmpdir os.chdir(testdir) file = os.path.join(testdir, 'foo') # Want to use twice total memsize kilobytes = 2 * memtotal() |
def execute(self, testdir = None, iterations = 1, filesize='200G'): cmd = os.path.join(self.srcdir + 'src/spew') | def execute(self, testdir = None, iterations = 1, filesize='100M'): cmd = os.path.join(self.srcdir, 'src/spew') | def execute(self, testdir = None, iterations = 1, filesize='200G'): cmd = os.path.join(self.srcdir + 'src/spew') if not testdir: testdir = self.testdir tmpfile = os.path.join(testdir, 'spew-test.%d' % os.getpid()) results = os.path.join(self.resultsdir, tmpfile) args = '-q -i %d -p random -b 2k -B 2M %s %s' % \ (iterat... |
testdir = self.testdir | testdir = self.tmpdir | def execute(self, testdir = None, iterations = 1, filesize='200G'): cmd = os.path.join(self.srcdir + 'src/spew') if not testdir: testdir = self.testdir tmpfile = os.path.join(testdir, 'spew-test.%d' % os.getpid()) results = os.path.join(self.resultsdir, tmpfile) args = '-q -i %d -p random -b 2k -B 2M %s %s' % \ (iterat... |
results = os.path.join(self.resultsdir, tmpfile) args = '-q -i %d -p random -b 2k -B 2M %s %s' % \ | results = os.path.join(self.resultsdir, 'stdout') args = '-i %d -p random -b 2k -B 2M %s %s' % \ | def execute(self, testdir = None, iterations = 1, filesize='200G'): cmd = os.path.join(self.srcdir + 'src/spew') if not testdir: testdir = self.testdir tmpfile = os.path.join(testdir, 'spew-test.%d' % os.getpid()) results = os.path.join(self.resultsdir, tmpfile) args = '-q -i %d -p random -b 2k -B 2M %s %s' % \ (iterat... |
if re.split(r'[.-]', version)[0:3] < ['2', '6', '16'] | if re.split(r'[.-]', version)[0:3] < ['2', '6', '16']: | def execute(self, dir, pages_requested = 20): # Check kernel version, should >= 2.6.16 version = system_output('uname -r') if re.split(r'[.-]', version)[0:3] < ['2', '6', '16'] raise TestError('Kernel version %s < 2.6.16' % version) # Check huge page number pages_available = 0 if os.path.exists('/proc/sys/vm/nr_hugepa... |
kernel = self.job.kernel(tarball, self.tmpdir) | kernel = self.job.kernel(tarball, self.tmpdir, self.srcdir) | def setup(self): # http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.14.tar.bz2 if (os.path.exists(self.bindir + '/linux-2.6.14.tar.bz2')): tarball = self.bindir + '/linux-2.6.14.tar.bz2' else: tarball = '/usr/local/src/linux-2.6.14.tar.bz2' kernel = self.job.kernel(tarball, self.tmpdir) kernel.config(defconfig=True) #... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.