rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
title = evt.GetLabel() | parentOpts.titles[titleIndex] = evt.GetLabel() | def OnTreeItemEdit(self, evt): """Update controls when a tree item's title is edited.""" if not evt.IsEditCancelled(): curItem = evt.GetItem() curOpts = self.discTree.GetPyData(curItem) curOpts.title = evt.GetLabel() # Assign outPrefix based on title curOpts.outPrefix = curOpts.title.replace(' ', '_') |
clause = In('usesysid', row.grolist) | if row.grolist is None: clause = None else: clause = 'usesysid in %s' % row.grolist | def get_users(self, group=None): clause = None if group is not None: clause = Eq('groname', group) row = self.db.select_row(fields=['grolist'], table='pg_group', clause=clause) clause = In('usesysid', row.grolist) fields = ['usename', 'usesysid'] return self.db.select(fields=fields, table='pg_user', clause=clause) |
print url, 'ur;l' | print url, 'url' | def setSource(self, url): print url, 'ur;l' action, context, id = str(url).split('.') fields = [context] dlg = SimpleRecordDialog(self, fields, name='hello') current = self.doc.records[int(id)].record[context] key = '%s-%s' % (self._action, id) self.dialogs[key] = dlg |
if __name__ == '__main__': | def backup(self): map(self.copyto, self.cursor.tables()) | |
class GzipPipe(PipeTemplate): | class GzipPipe(_zipPipe): | def __init__(self, cmd, decompress): PipeTemplate.__init__(self) if decompress: cmd.append(' -d') self.append(cmd, '--') |
class BzipPipe(PipeTemplate): | class BzipPipe(_zipPipe): | def __init__(self, decompress=False): _zipPipe.__init__(self, 'gzip', decompress) |
print package, ' was corrupt, got it' | print lpath, ' was corrupt, got it' | def get_file(rpath, lpath, result='gone'): dir, package = os.path.split(lpath) if result == 'corrupt': while isfile(lpath): os.remove(lpath) wget(rpath, lpath) print package, ' was corrupt, got it' else: print package, ' not there' makepaths(dir) wget(rpath, lpath) |
if __name__ == '__main__': | def create_table(self, table): if table.name[:7] != 'lp_log_': StatementCursor.create_table(self, table) logtable = LogTable(table) StatementCursor.create_table(self, logtable) self.create_trigger(ActionTrigger(table.name)) | |
if self.__fileHandle!=None: | if self.__fileHandle is not None: | def close(self): """ Closes the file if it is open. |
self.__fileHandle==None | self.__fileHandle=None | def close(self): """ Closes the file if it is open. |
self.__fileHandle=urllib2.urlopen(self.__pathStr) | if mode in ('r','rb'): self.__fileHandle=urllib2.urlopen(self.__pathStr) elif mode in ('w','wb','a','ab'): raise ufsi.UnsupportedOperationError( 'HTTP has no facility to write.') else: raise ufsi.InvalidArgumentError('Unknown mode %r'%mode) | def open(self,mode=None): """ Opens a HTTP connection to the file. If a previous connection was opened it is first closed. TODO: currently, mode is ignored but we should do a little more validation on it. """ self.close() self.__fileHandle=urllib2.urlopen(self.__pathStr) |
otherStr=str(other) return ufsi.Path(os.path.join(self.__path,otherStr)) | if not isinstance(other,ufsi.PathInterface): other=ufsi.Path(other) if other.isAbsolute(): return other selfSep=self.getSeparator() otherStr=str(other).replace(other.getSeparator(),selfSep) selfStr=self._path if not selfStr.endswith(selfSep): selfStr=selfStr+selfSep if otherStr.startswith(selfSep): otherStr=otherStr... | def join(self,other): """ Joins ``other`` onto the end of this path and returns a new Path object. ``other`` must be a string or a Path object. """ # TODO: should we take a list of other, as os.path does otherStr=str(other) return ufsi.Path(os.path.join(self.__path,otherStr)) |
return os.path.isabs(self.__path) | return os.path.isabs(self._path) | def isAbsolute(self): """ Returns True if the path is an absolute path, False otherwise. """ return os.path.isabs(self.__path) |
(head,tail)=os.path.split(self.__path) dirs=head.split('/') (fileBase,fileExt)=os.path.splitext(tail) | dirs=self._path.split('/') fileName=dirs.pop() fileParts=fileName.rsplit('.',1) fileExt=None if len(fileParts)>1: fileExt=fileParts[1] fileBase=fileParts[0] | def split(self): """ Splits the path into: |
return d | return d.copy() | def split(self): """ Splits the path into: |
if info.has_key('title'): if type(info['title']) not in (UnicodeType, ): info['title'] = udecode(info['title']).encode(enc) if info.has_key('description'): if type(info['description']) not in (UnicodeType, ): info['description'] = udecode(info['description']).encode(enc) | encoding = parsed_data.get('encoding', 'ascii') for key in ('description', 'tagline', 'title'): if isinstance(info[key], basestring) and not isinstance(info[key], unicode): info[key] = udecode(info[key], encoding) | def encode(self, parsed_data): # Get site encoding |
if r.has_key('title'): if type(r['title']) not in (UnicodeType, ): r['title'] = udecode(r['title']).encode(enc) | for key in ('description', 'source', 'summary', 'title'): if isinstance(r[key], basestring) and not isinstance(r[key], unicode): r[key] = udecode(r[key], encoding) | def encode(self, parsed_data): # Get site encoding |
for r in self.s.rows: if self.fillOne(r): self.fillAll() return | def fillAll(self): # rows for r in self.s.rows: if self.fillOne(r): self.fillAll() return # waste if not self.s.waste.cards and self.s.talon.cards: self.s.talon.dealCards() if self.fillOne(self.s.waste): self.fillAll() | |
if stack in self.s.rows: if not stack.cards and self.s.waste.cards: self.s.waste.moveMove(1, stack) | def fillStack(self, stack): if stack in self.s.rows: if not stack.cards and self.s.waste.cards: self.s.waste.moveMove(1, stack) self.fillAll() | |
value, end = JSONScanner.iterscan(s, idx=end).next() | value, end = iterscan(s, idx=end, context=context).next() | def JSONObject(match, context, _w=WHITESPACE.match): pairs = {} s = match.string end = _w(s, match.end()).end() nextchar = s[end:end + 1] # trivial empty object if nextchar == '}': return pairs, end + 1 if nextchar != '"': raise ValueError(errmsg("Expecting property name", s, end)) end += 1 encoding = getattr(context, ... |
value, end = JSONScanner.iterscan(s, idx=end).next() | value, end = iterscan(s, idx=end, context=context).next() | def JSONArray(match, context, _w=WHITESPACE.match): values = [] s = match.string end = _w(s, match.end()).end() # look-ahead for trivial empty array nextchar = s[end:end + 1] if nextchar == ']': return values, end + 1 while True: try: value, end = JSONScanner.iterscan(s, idx=end).next() except StopIteration: raise Valu... |
res = simple_json.dumps(app(environ, json_start_response)) | res = simplejson.dumps(self.app(environ, json_start_response)) | def json_start_response(status, headers): response['status'] = status response['headers'].extend(headers) |
def read(self, data): | def read(self, size=1024): | def read(self, data): if self.blocking: return self._read_bio(data) return self._read_nbio(data) |
return self._read_bio(data) return self._read_nbio(data) | return self._read_bio(size) return self._read_nbio(size) | def read(self, data): if self.blocking: return self._read_bio(data) return self._read_nbio(data) |
asn1.set_string('990807053011Z') assert str(asn1) == 'Aug 7 05:30:11 1999 GMT' | format = '%b %d %H:%M:%S %Y GMT' utcformat = '%y%m%d%H%M%SZ' s = '990807053011Z' asn1.set_string(s) t1 = time.strptime(str(asn1), format) t2 = time.strptime(s, utcformat) assert t1 == t2 | def check_UTCTIME(self): asn1 = ASN1.ASN1_UTCTIME() assert str(asn1) == 'Bad time value' asn1.set_string('990807053011Z') assert str(asn1) == 'Aug 7 05:30:11 1999 GMT' asn1.set_time(500) assert str(asn1) == 'Jan 1 00:08:20 1970 GMT' t = long(time.time()) + time.timezone asn1.set_time(t) t2 = time.strftime('%b %d %... |
assert str(asn1) == 'Jan 1 00:08:20 1970 GMT' | t1 = time.strftime(format, time.strptime(str(asn1), format)) t2 = time.strftime(format, time.gmtime(500)) assert t1 == t2 | def check_UTCTIME(self): asn1 = ASN1.ASN1_UTCTIME() assert str(asn1) == 'Bad time value' asn1.set_string('990807053011Z') assert str(asn1) == 'Aug 7 05:30:11 1999 GMT' asn1.set_time(500) assert str(asn1) == 'Jan 1 00:08:20 1970 GMT' t = long(time.time()) + time.timezone asn1.set_time(t) t2 = time.strftime('%b %d %... |
t2 = time.strftime('%b %d %H:%M:%S %Y', time.gmtime(t)) assert str(asn1)[:-4] == str(t2) | t1 = time.strftime(format, time.strptime(str(asn1), format)) t2 = time.strftime(format, time.gmtime(t)) assert t1 == t2 | def check_UTCTIME(self): asn1 = ASN1.ASN1_UTCTIME() assert str(asn1) == 'Bad time value' asn1.set_string('990807053011Z') assert str(asn1) == 'Aug 7 05:30:11 1999 GMT' asn1.set_time(500) assert str(asn1) == 'Jan 1 00:08:20 1970 GMT' t = long(time.time()) + time.timezone asn1.set_time(t) t2 = time.strftime('%b %d %... |
self.handle_error() | self.handle_error(request, client_address) | def handle_request(self): try: request, client_address = self.get_request() if self.verify_request(request, client_address): self.process_request(request, client_address) except SSLError: self.handle_error() |
def handle_error(self): | def handle_error(self, request, client_address): | def handle_error(self): print '-'*40 import traceback traceback.print_exc() print '-'*40 |
def swig_sources (self, sources): | 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... | |
def swig_sources (self, sources): | 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... | |
new_sources = [] swig_sources = [] swig_targets = {} | 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... | |
new_sources = [] swig_sources = [] swig_targets = {} | 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... | |
if self.swig_cpp: target_ext = '.cpp' else: target_ext = '.c' | 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... | |
for source in sources: (base, ext) = os.path.splitext(source) if ext == ".i": new_sources.append(base + target_ext) swig_sources.append(source) swig_targets[source] = new_sources[-1] | if self.swig_cpp: target_ext = '.cpp' | 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... |
new_sources.append(source) | target_ext = '.c' | 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... |
if not swig_sources: | for source in sources: (base, ext) = os.path.splitext(source) if ext == ".i": new_sources.append(base + target_ext) swig_sources.append(source) swig_targets[source] = new_sources[-1] else: new_sources.append(source) if not swig_sources: return new_sources swig = self.find_swig() swig_cmd = [swig, "-python", "-ISWIG"]... | 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... |
swig = self.find_swig() swig_cmd = [swig, "-python", "-ISWIG"] if self.swig_cpp: swig_cmd.append("-c++") for source in swig_sources: target = swig_targets[source] self.announce("swigging %s to %s" % (source, target)) self.spawn(swig_cmd + ["-o", target, source]) return new_sources build_ext.build_ext.swig_sources = ... | build_ext.build_ext.swig_sources = swig_sources | 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... |
ctx = SSL.Context() s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_server_simple(self): pid = self.start_server(self.args) ctx = SSL.Context() s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) self.failIf(string.find(data, 's_server -quiet -www') == -1) |
ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'wrong version number') s.close() self.stop_server(pid) | try: ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'wrong version number') s.close() finally: self.stop_server(pid) | def test_tls1_nok(self): self.args.append('-no_tls1') pid = self.start_server(self.args) ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'wrong version number') s.close() self.stop_server(pid) |
ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_tls1_ok(self): self.args.append('-tls1') pid = self.start_server(self.args) ctx = SSL.Context('tlsv1') s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) self.failIf(string.find(data, 's_server -quiet -www') == -1) |
ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv3') s.close() self.stop_server(pid) | try: ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv3') s.close() finally: self.stop_server(pid) | def test_sslv23_no_v2(self): self.args.append('-no_tls1') pid = self.start_server(self.args) ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv3') s.close() self.stop_server(pid) |
ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'unsupported protocol') s.close() self.stop_server(pid) | try: ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'unsupported protocol') s.close() finally: self.stop_server(pid) | def test_sslv23_no_v2_no_service(self): self.args = self.args + ['-no_tls1', '-no_ssl3'] pid = self.start_server(self.args) ctx = SSL.Context('sslv23') s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'unsupported protocol') s.close() self.stop_server(pid) |
ctx = SSL.Context('sslv23', weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv2') s.close() self.stop_server(pid) | try: ctx = SSL.Context('sslv23', weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv2') s.close() finally: self.stop_server(pid) | def test_sslv23_weak_crypto(self): self.args = self.args + ['-no_tls1', '-no_ssl3'] pid = self.start_server(self.args) ctx = SSL.Context('sslv23', weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) self.failUnlessEqual(s.get_version(), 'SSLv2') s.close() self.stop_server(pid) |
ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-CBC-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close() self.stop_server(pid) | try: ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-CBC-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close() finally: self.stop_server(pid) | def test_cipher_mismatch(self): self.args = self.args + ['-cipher', 'EXP-RC4-MD5'] pid = self.start_server(self.args) ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-CBC-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close... |
ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'no ciphers available') s.close() self.stop_server(pid) | try: ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'no ciphers available') s.close() finally: self.stop_server(pid) | def test_no_such_cipher(self): self.args = self.args + ['-cipher', 'EXP-RC4-MD5'] pid = self.start_server(self.args) ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC2-MD5') try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'no ciphers available') s.close() self.stop_s... |
ctx = SSL.Context() s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close() self.stop_server(pid) | try: ctx = SSL.Context() s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close() finally: self.stop_server(pid) | def test_no_weak_cipher(self): self.args = self.args + ['-cipher', 'EXP'] pid = self.start_server(self.args) ctx = SSL.Context() s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: self.failUnlessEqual(e[0], 'sslv3 alert handshake failure') s.close() self.stop_server(pid) |
ctx = SSL.Context(weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context(weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_use_weak_cipher(self): self.args = self.args + ['-cipher', 'EXP'] pid = self.start_server(self.args) ctx = SSL.Context(weak_crypto=1) s = SSL.Connection(ctx) s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) self.failIf(string.find(data, 's_server -quiet -www') == -1) |
ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC4-MD5') s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC4-MD5') s.connect(self.srv_addr) data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_cipher_ok(self): self.args = self.args + ['-cipher', 'EXP-RC4-MD5'] pid = self.start_server(self.args) ctx = SSL.Context() s = SSL.Connection(ctx) s.set_cipher_list('EXP-RC4-MD5') s.connect(self.srv_addr) data = self.http_get(s) s.close() self.stop_server(pid) self.failIf(string.find(data, 's_server -quiet -ww... |
ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_new) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_new) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_verify_cb_new(self): pid = self.start_server(self.args) ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_new) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) ... |
ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, VerifyCB()) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, VerifyCB()) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_verify_cb_new_class(self): pid = self.start_server(self.args) ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, VerifyCB()) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) se... |
ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, verify_cb_new_function) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, verify_cb_new_function) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_verify_cb_new_function(self): pid = self.start_server(self.args) ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, verify_cb_new_function) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop... |
ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_exception) s = SSL.Connection(ctx) self.assertRaises(SSL.SSLError, s.connect, self.srv_addr) s.close() self.stop_server(pid) | try: ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_exception) s = SSL.Connection(ctx) self.assertRaises(SSL.SSLError, s.connect, self.srv_addr) s.close() finally: self.stop_server(pid) | def test_verify_cb_exception(self): pid = self.start_server(self.args) ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_exception) s = SSL.Connection(ctx) self.assertRaises(SSL.SSLError, s.connect, self.srv_addr) s.close() self.stop_server(pid) |
ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_old) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) | try: ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_old) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() finally: self.stop_server(pid) | def test_verify_cb_old(self): pid = self.start_server(self.args) ctx = SSL.Context() ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert, 9, self.verify_cb_old) s = SSL.Connection(ctx) try: s.connect(self.srv_addr) except SSL.SSLError, e: assert 0, e data = self.http_get(s) s.close() self.stop_server(pid) ... |
startTLS = 1 def getContext(self): ctx = SSL.Context() return ctx def sslChecker(self, x509, host): check = SSL.Checker.Checker(host=srv_host, peerCertHash='545C873E4FF7E31BF439D80C9F5F128DF7E3EE57') return check(x509) | def lineReceived(self, line): global twisted_data twisted_data += line | |
global twisted_data twisted_data = '' factory = EchoClientFactory() wrappingFactory = WrappingFactory(factory) wrappingFactory.protocol = TLSProtocolWrapper reactor.connectTCP(srv_host, srv_port, wrappingFactory) reactor.run() self.stop_server(pid) | try: global twisted_data twisted_data = '' factory = EchoClientFactory() wrappingFactory = WrappingFactory(factory) wrappingFactory.protocol = TLSProtocolWrapper reactor.connectTCP(srv_host, srv_port, wrappingFactory) reactor.run() finally: self.stop_server(pid) | def clientConnectionLost(self, connector, reason): reactor.stop() |
m2.bio_free(self.sslbio) m2.bio_free(self.sockbio) | m2.bio_free_all(self.sslbio) | def close(self): m2.ssl_shutdown(self.ssl) try: m2.bio_free(self.sslbio) m2.bio_free(self.sockbio) except AttributeError: pass self.socket.close() |
return self._check_ssl_return(m2.ssl_accept(self.ssl)) | return m2.ssl_accept(self.ssl) | def accept_ssl(self): return self._check_ssl_return(m2.ssl_accept(self.ssl)) |
else: self.send = self.write = self._write_bio self.recv = self.read = self._read_bio | def setblocking(self, mode): self.socket.setblocking(mode) if mode: self.send = self.write = self._write_nbio self.recv = self.read = self._read_nbio else: self.send = self.write = self._write_bio self.recv = self.read = self._read_bio | |
def _makefile(self, mode='rw', bufsize=1024): 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, sockbio) return BIO.IOBuffer(sslbio, mode, bufsize) | def get_cipher_list(self, idx=0): return m2.ssl_get_cipher_list(self.ssl, idx) def set_cipher_list(self, cipher_list): return m2.ssl_set_cipher_list(self.ssl, cipher_list) | def _makefile(self, mode='rw', bufsize=1024): # XXX Doesn't work. #sockbio = m2.bio_dup_chain(self.sockbio) 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, sockbio) return BIO.IOBuffer(sslbio, mode, bufsize) |
'emailAddress' : m2.NID_pkcs9_emailAddress | 'emailAddress' : m2.NID_pkcs9_emailAddress, 'serialNumber' : m2.NID_serialNumber, 'SN' : m2.NID_surname, 'surname' : m2.NID_surname, 'GN' : m2.NID_givenName, 'givenName' : m2.NID_givenName | def create_by_txt( self, field, type, entry, len): return m2.x509_name_entry_create_by_txt( self.x509_name_entry._ptr(), field, type, entry, len ) |
def __init__(self, this=m2.dh_new()): self.this=this | def __init__(self, this=None, _pyfree=0): if this is not None: self.this = this self._pyfree = _pyfree else: self.this = m2.dh_new() self._pyfree = 1 | def __init__(self, this=m2.dh_new()): self.this=this |
def __del__(self): m2.dh_free(self.this) | def __del__(self): if self._pyfree: m2.dh_free(self.this) | def __del__(self): m2.dh_free(self.this) |
return DH(this=m2.dh_generate_parameters(plen, g, callback)) | return DH(m2.dh_generate_parameters(plen, g, callback), 1) | def gen_params(plen, g, callback=genparam_callback): return DH(this=m2.dh_generate_parameters(plen, g, callback)) |
bio = BIO.openfile(filepath, 'wb') | bio = BIO.openfile(filename, 'wb') | def save_key(self, filename, cipher='aes_128_cbc', callback=util.passphrase_callback): """ Save the DSA key pair to a file. @type filename: str @param filename: Save the DSA key pair to this file. @type cipher: str @param cipher: name of symmetric key algorithm and mode to encrypt the private key. @return: ... |
bio = BIO.openfile(filepath, 'wb') | bio = BIO.openfile(filename, 'wb') | def save_pub_key(self, filename): """ Save the DSA public key (with parameters) to a file. @type filename: str @param filename: Save DSA public key (with parameters) to this file. @return: 1 (true) if successful """ bio = BIO.openfile(filepath, 'wb') ret = self.save_pub_key_bio(bio) bio.close() return ret |
return self.connect_ssl() | 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.SSLVerificationError, 'post connection check failed' return ret | def connect(self, addr): self.socket.connect(addr) self.addr = addr self.setup_ssl() self.set_connect_state() return self.connect_ssl() |
'-DSWIG_COBJECT_PYTHON'] | '-DSWIG_COBJECT_PYTHON'], swig_opts = swig_opts | def swig_sources (self, sources): |
version = '0.13', | version = '0.14s1', | def swig_sources (self, sources): |
return urllib.addinfourl(fp, {}, "https:" + url) | return urllib.addinfourl(fp, resp.msg, "https:" + url) | def open_https(self, url, data=None, ssl_context=None): if ssl_context is not None and isinstance(ssl_context, SSL.Context): self.ctx = ssl_context else: self.ctx = SSL.Context(DEFAULT_PROTOCOL) user_passwd = None if type(url) is type(""): host, selector = splithost(url) if host: user_passwd, host = splituser(host) hos... |
if __name__=='__main__': r=load_pem('fred.pem') print r.e print r.n | def load_key(file, callback=passphrase_callback): f=open(file) r=rsa_read_key(f, callback) f.close() return RSA(r) | |
SSL.ssl_dispatcher.__init__(self, conn) | asyncore.dispatcher.__init__(self, conn) self._ssl_accepting = 1 | def __init__(self, conn): SSL.ssl_dispatcher.__init__(self, conn) self.peer = self.get_peer_cert() |
def writeable(self): return len(self.buffer) > 0 | def writable(self): return self._ssl_accepting or (len(self.buffer) > 0) | def writeable(self): return len(self.buffer) > 0 |
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() | if self._ssl_accepting: s = self.socket.accept_ssl() if s: self._ssl_accepting = 0 else: try: n = self.send(self.buffer) if n == -1: pass elif n == 0: self.handle_close() else: self.buffer = self.buffer[n:] except SSL.SSLError, what: if str(what) == 'unexpected eof': self.handle_close() return else: raise | def handle_write(self): 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() |
try: blob=self.recv() if blob is None: pass elif blob == '': self.handle_close() else: self.buffer = self.buffer + blob except: self.close() | if self._ssl_accepting: s = self.socket.accept_ssl() if s: self._ssl_accepting = 0 else: try: blob = self.recv(4096) if blob is None: pass elif blob == '': self.handle_close() else: self.buffer = self.buffer + blob except SSL.SSLError, what: if str(what) == 'unexpected eof': self.handle_close() return else: raise | def handle_read(self): try: blob=self.recv() if blob is None: pass elif blob == '': self.handle_close() else: self.buffer = self.buffer + blob except: self.close() |
def writeable(self): | def writable(self): | def writeable(self): return 0 |
ctx=echod_lib.init_context('sslv23', 'server.pem', 'ca.pem', \ SSL.verify_none) | ctx = echod_lib.init_context('sslv23', 'server.pem', 'ca.pem', \ SSL.verify_peer | SSL.verify_fail_if_no_peer_cert) | def writeable(self): return 0 |
raise ValueError, 'unknown algorithm' | raise ValueError, ('unknown algorithm', algo) | def __init__(self, algo): md = getattr(m2, algo) if not md: raise ValueError, 'unknown algorithm' self.md=md() self.ctx=m2.md_ctx_new() m2.digest_init(self.ctx, self.md) |
raise ValueError, 'unknown algorithm' | raise ValueError, ('unknown algorithm', algo) | def __init__(self, algo, key): md = getattr(m2, algo) if not md: raise ValueError, 'unknown algorithm' self.md=md() self.ctx=m2.hmac_ctx_new() m2.hmac_init(self.ctx, key, self.md) |
raise ValueError, 'unknown cipher' | raise ValueError, ('unknown cipher', alg) | def __init__(self, alg, key, iv, op, key_as_bytes=0, d='md5', salt='', i=1): cipher = getattr(m2, alg) if not cipher: raise ValueError, 'unknown cipher' self.cipher=cipher() if key_as_bytes: kmd = getattr(m2, d) if not kmd: raise ValueError, 'unknown message digest' key = m2.bytes_to_key(self.cipher, kmd(), key, salt, ... |
raise ValueError, 'unknown message digest' | raise ValueError, ('unknown message digest', d) | def __init__(self, alg, key, iv, op, key_as_bytes=0, d='md5', salt='', i=1): cipher = getattr(m2, alg) if not cipher: raise ValueError, 'unknown cipher' self.cipher=cipher() if key_as_bytes: kmd = getattr(m2, d) if not kmd: raise ValueError, 'unknown message digest' key = m2.bytes_to_key(self.cipher, kmd(), key, salt, ... |
def __init__(self, md, pkey=m2.pkey_new()): self.pkey=pkey md = getattr(m2, md) if not md: raise ValueError, 'unknown message digest' self.md = md() | def __init__(self, md, pkey=None): if pkey is None: self.pkey = m2.pkey_new() else: self.pkey = pkey mda = getattr(m2, md) if not mda: raise ValueError, ('unknown message digest', md) self.md = mda() | def __init__(self, md, pkey=m2.pkey_new()): self.pkey=pkey md = getattr(m2, md) if not md: raise ValueError, 'unknown message digest' self.md = md() |
if self.pkey: m2.pkey_free(self.pkey) | m2.pkey_free(self.pkey) | def __del__(self): if self.pkey: m2.pkey_free(self.pkey) |
def read(self, size=1024): if not self.readable(): raise m2.Error("write-only") if self.closed or size<=0: return '' try: return m2.bio_read(self.bio, size) except RuntimeError: return '' | def read(self, size=4096): if not self.readable(): raise m2.Error("write-only") if self.closed or size<=0: return '' try: return m2.bio_read(self.bio, size) except RuntimeError: return '' | def read(self, size=1024): if not self.readable(): raise m2.Error("write-only") if self.closed or size<=0: return '' try: return m2.bio_read(self.bio, size) except RuntimeError: # XXX better error handling return '' |
def __init__(self, pyfile, close_flag=1): BIO.__init__(self) self.pyfile=pyfile self.close_flag=close_flag self.bio=m2.bio_new_fp(pyfile, close_flag) | def __init__(self, pyfile, close_flag=0): BIO.__init__(self) self.pyfile=pyfile self.close_flag=close_flag self.bio=m2.bio_new_fp(pyfile, 0) | def __init__(self, pyfile, close_flag=1): BIO.__init__(self) self.pyfile=pyfile self.close_flag=close_flag self.bio=m2.bio_new_fp(pyfile, close_flag) |
def close(self): if self.close_flag==1: self.pyfile.close() self.closed=1 | def __del__(self): m2.bio_free(self.bio) self.pyfile.close() | def close(self): if self.close_flag==1: self.pyfile.close() self.closed=1 |
def send(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 0 else: return n | def recv(self, size=4096): return self.socket.recv(size) | def send(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: # Only in non-blocking mode. return -1 else: if n==0: # In non-blocking SSL, this means 'try again'. retur... |
def recv(self, size=4096): (n, blob, err)=m2.ssl_read_nbio(self.ssl, size) if n==-1: if err==m2.ssl_error_zero_return: return '' elif err in [m2.ssl_error_ssl, m2.ssl_error_syscall]: m2.err_print_errors_fp(sys.stderr) raise Err.SSLError(n, self.socket.getpeername()) else: return None else: return blob | def send(self, buffer): return self.socket.send(buffer) | def recv(self, size=4096): (n, blob, err)=m2.ssl_read_nbio(self.ssl, size) if n==-1: if err==m2.ssl_error_zero_return: return '' elif err in [m2.ssl_error_ssl, m2.ssl_error_syscall]: m2.err_print_errors_fp(sys.stderr) raise Err.SSLError(n, self.socket.getpeername()) else: return None # XXX None is overloaded to mean 't... |
def read_all(self): try: | def read(self, size=0): if size: return m2.bio_read(self.bio, size) else: | def read_all(self): try: return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio)) except: return '' |
except: return '' | def read_all(self): try: return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio)) except: return '' | |
getvalue = read_all | getvalue = read_all = read | def read_all(self): try: return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio)) except: return '' |
and OpenSSL functions that expect BIO *. If you wish to manipulate files in Python, use Python's file object.""" | and OpenSSL functions that expect BIO *. For general file manipulation in Python, use Python's file object.""" | def read_all(self): try: return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio)) except: return '' |
proxyfile = open(proxypath, "w") | proxyfile = create_write_file(proxypath) | def write(self, proxypath=None): """ Writes the proxy information to a file """ proxyfile = open(proxypath, "w") bio = BIO.File(proxyfile) bio.write(self._cert.as_pem()) self._key.save_key_bio(bio, cipher=None) bio.write(self._issuer.as_pem()) bio.close() os.chmod(proxypath, 0600) |
g = m2.bio_ctrl_get_write_guarantee(self.sslBio._ptr()) if g > 0 and self.data != '' or clientHello: r = m2.bio_write(self.sslBio._ptr(), self.data) if r <= 0: assert(m2.bio_should_retry(self.sslBio._ptr())) else: assert(self.checked) self.data = self.data[r:] encryptedData = '' | def _encrypt(self, data='', clientHello=0): # XXX near mirror image of _decrypt - refactor self.data += data g = m2.bio_ctrl_get_write_guarantee(self.sslBio._ptr()) if g > 0 and self.data != '' or clientHello: r = m2.bio_write(self.sslBio._ptr(), self.data) if r <= 0: assert(m2.bio_should_retry(self.sslBio._ptr())) els... | |
g = m2.bio_ctrl_get_write_guarantee(self.networkBio) if g > 0 and self.encrypted != '': r = m2.bio_write(self.networkBio, self.encrypted) if r <= 0: assert(m2.bio_should_retry(self.networkBio)) else: self.encrypted = self.encrypted[r:] | def _decrypt(self, data=''): # XXX near mirror image of _encrypt - refactor self.encrypted += data g = m2.bio_ctrl_get_write_guarantee(self.networkBio) if g > 0 and self.encrypted != '': r = m2.bio_write(self.networkBio, self.encrypted) if r <= 0: assert(m2.bio_should_retry(self.networkBio)) else: self.encrypted = self... | |
self.map = {} | self.map = WeakValueDictionary() | def __init__(self): self.map = {} |
if not self._match(self.host, subjectAltName, True): | if not self._splitSubjectAltName(self.host, subjectAltName): | def __call__(self, peerCert, host=None): if peerCert is None: raise NoCertificate('peer did not return certificate') |
def _match(self, host, certHost, subjectAltName=False): | def _splitSubjectAltName(self, host, subjectAltName): | 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:my.example.com', subjectAltName=True) | >>> check._splitSubjectAltName(host='my.example.com', subjectAltName='DNS:my.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:*.example.com', subjectAltName=True) | >>> check._splitSubjectAltName(host='my.example.com', subjectAltName='DNS:*.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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.