def hash(self, password, salt): password = self.pre_hashing(password) # 1. Let S be the following byte sequence (called the padding): # (u = len(password) (in bytes)) # S = H_(k−2−u)(salt || password || u) k = len(encode(self.n)) u = len(password) # u must be such that u ≤ 255 and u ≤ k − 32 if u > 255 or u > k - 32: raise ValueError('Password is too long') S = self.kdf(salt + password + pack('=B', u), k - 2 - u) # 2. Let X be the following byte sequence: # X = 0x00 | | S | | π | | u X = b'\x00' + S + password + pack('=B', u) # 3. Let x be the integer obtained by decoding X with OS2IP. x = decode(X) # 4. Compute: # y = x^(2^(w+1)) (mod n) # This computation is normally performed by repeatedly squaring x modulo n; this is # done w + 1 times. y = x for _ in range(self.w + 1): y = pow(y, 2, self.n) # 5. Encode y with I2OSP into the byte sequence Y of length k bytes. Y = encode(y, k) # The primary output of MAKWA is Y return self.post_hashing(Y)
def transmit(freqs, bit_rates, send_bits, **kwargs): # Compress ->bits # Freq Multiplex # Coding # Modulate print('Frequencies: {}'.format(freqs)) print('Min freq: {}, Max freq: {}'.format(min(freqs), max(freqs))) print('bit_rates: {}'.format(bit_rates)) hamming = False enc.encode('bin.wav', send_bits, freqs, bit_rates, hamming=hamming, plot_audio=False) print('Duration: {}'.format(utils.get_wav_duration('bin.wav'))) print('No of bits: {}'.format(len(send_bits))) input('>>Press enter to play') am.play_wav('bin.wav') am.sd.wait()
def submit_audio(user_id, index, tick): payload = encoding.decode(request.data) segment = read_opus(payload['sound']) offset = payload['offset'] offset_sign = payload['offset-sign'] room_id = r.get('USER-ROOM:%s' % user_id).decode('utf-8') room_index = int(r.get('ROOM-INDEX:%s' % room_id)) room_song = r.get('ROOM-SONG:%s' % room_id) if room_index != index or room_song is None: return encoding.encode({ 'success': False, 'reason': 'Desynced with the bulletin' }) if not offset_sign: segment = segment[offset:] offset = 0 r.set('USER-AUDIO-%d:%s' % (tick % 2, user_id), encoding.encode( { 'offset': offset, 'sound': as_mp3(segment) }) ) r.set('USER-LAST-ACTIVE:%s' % user_id, int(time.time())) return encoding.encode({'success': True})
def showitems(self): lines = [] stats = hub.request(requests.getsongdbmanagerstats()) indent = " " * 3 for songdbstats in stats.songdbsstats: dbidstring = _("Database %s") % songdbstats.id + ":" dbstatstring = _("%d songs, %d albums, %d artists, %d tags") % ( songdbstats.numberofsongs, songdbstats.numberofalbums, songdbstats.numberofartists, songdbstats.numberoftags) lines.append((dbidstring, dbstatstring)) if songdbstats.type == "local": dbtypestring = _("local database (db file: %s)") % ( songdbstats.dbfile) else: dbtypestring = _("remote database (server: %s)") % ( songdbstats.location) lines.append((indent + _("type") + ":", dbtypestring)) lines.append( (indent + _("base directory") + ":", songdbstats.basedir)) dbcachesizestring = "%dkB" % songdbstats.cachesize lines.append((indent + _("cache size") + ":", dbcachesizestring)) lines.append(("", "")) cachestatsstring = _("%d requests, %d / %d objects") % ( stats.requestcacherequests, stats.requestcachesize, stats.requestcachemaxsize) if stats.requestcachemaxsize != 0: cachestatsstring = cachestatsstring + " (%d%%)" % ( 100 * stats.requestcachesize // stats.requestcachemaxsize) lines.append((_("Request cache size") + ":", cachestatsstring)) totalrequests = stats.requestcachehits + stats.requestcachemisses if totalrequests != 0: percentstring = " (%d%%)" % (100 * stats.requestcachehits // totalrequests) else: percentstring = "" lines.append( (_("Request cache stats") + ":", (_("%d hits / %d requests") % (stats.requestcachehits, totalrequests)) + percentstring)) wc1 = max([len(lc) for lc, rc in lines]) + 1 if wc1 > 0.6 * self.iw: wc1 = int(0.6 * self.iw) wc2 = self.iw - wc1 y = self.iy for lc, rc in lines: self.move(y, self.ix) self.addstr( encoding.encode(lc).ljust(wc1)[:wc1], self.colors.description) self.addstr( encoding.encode(rc).ljust(wc2)[:wc2], self.colors.content) y += 1
def get_bulletin(room_id): bulletin = encoding.decode(r.get('ROOM-BULLETIN:%s' % room_id)) index = int(r.get('ROOM-INDEX:%s' % room_id)) if bulletin is None: return encoding.encode({'success': False}) return encoding.encode({ 'index': index, 'bulletin': bulletin })
def update(self): window.window.update(self) self.move(0,0) self.clrtoeol() if self.message: self.addstr(encoding.encode(self.message), config.colors.statusbar.key) else: for element in self.content[0]+separator+self.content[1]+separator+self.content[2]: if element==terminate[0]: break self.addstr(encoding.encode(element[0]), element[1])
def enc(): global statement, img_p, var1, path if img_p == '': messagebox.showerror("ERROR", "Select an image") return ec.encode(statement, img_p) r = messagebox.askyesno("Quit", "Do you wish to continue?") if r == 0: root.quit() else: top3.withdraw() guid()
def record_f_er_br(am, filename, freq_params, br_params): min_freq, max_freq, freq_div = freq_params min_br, max_br, br_div = br_params frequencies = [ min_freq + (max_freq - min_freq) * i / freq_div for i in range(freq_div) ] bit_rates = [ min_br + (max_br - min_br) * i / br_div for i in range(br_div) ] fr = [] er = [] br = [] for freq in frequencies: for phy_bit_rate in bit_rates: print('Frequency: {}'.format(freq)) print('bit_rate: {}'.format(phy_bit_rate)) hamming = False enc.encode('bin.wav', testbits, [freq], phy_bit_rate, hamming=hamming) am.playrec('bin.wav', '_bin.wav', plot_ideal_signal=False) ans = dec.decode('_bin.wav', phy_bit_rate, len(testbits), [freq], hamming=hamming, plot_sync=False, plot_main=False) # print(ans) # print(list(tests.testbits)) error = utils.calc_error(testbits, ans) # utils.plot_smooth_error_graph(tests.testbits, ans) if list(ans) == list(testbits): print("YEET!") else: print("S***E") print('') fr.append(freq) br.append(phy_bit_rate) er.append(error) with open(filename, 'a') as f: for i in zip(fr, er, br): f.write('{}, {}, {}\n'.format(i[0], i[1], i[2]))
def showitems(self): y = self.iy for item in self.items[self.first:]: self.addstr(y, 1, " " * self.iw, self.colors.background) self.move(y, 1) for keyname in item[0][:-1]: self.addstr(encoding.encode(keyname), self.colors.key) self.addstr("/", self.colors.description) self.addstr(encoding.encode(item[0][-1]), self.colors.key) self.addnstr(y, 35, encoding.encode(item[1]), self.iw - 35) y += 1 if y >= self.iy + self.ih: break
def create_room(): bulletin = encoding.decode(request.data) room_id = generate_id(); # Every room has three things: # a list of users, a song, and a current tick. #r.set('ROOM-USERS:%s' % room_id, []) # Created implicitly r.set('ROOM-BULLETIN:%s' % room_id, encoding.encode(bulletin)) r.set('ROOM-INDEX:%s' % room_id, -1) return encoding.encode({'room_id': room_id})
def showitems(self): y = self.iy for item in self.items[self.first:]: self.addstr(y, 1, " "*self.iw, self.colors.background) self.move(y, 1) for keyname in item[0][:-1]: self.addstr(encoding.encode(keyname), self.colors.key) self.addstr("/", self.colors.description) self.addstr(encoding.encode(item[0][-1]), self.colors.key) self.addnstr(y, 35, encoding.encode(item[1]), self.iw-35) y += 1 if y>=self.iy+self.ih: break
def stop_song(room_id): users = r.lrange('ROOM-USERS:%s' % room_id, 0, -1) if users is None: return encoding.encode({'success': False}) # Stop playing this song r.delete('ROOM-SONG:%s' % room_id) # Delete everyone's audio for user in users: r.delete('USER-AUDIO-0:%s' % user.decode('utf-8')) r.delete('USER-AUDIO-1:%s' % user.decode('utf-8')) return encoding.encode({'success': True})
def playbackinfochanged(self, event): if event.playbackinfo.playerid == self.playerid: if self.song != event.playbackinfo.song and event.playbackinfo.song and self.songchangecommand: os.system(event.playbackinfo.song.format(self.songchangecommand, safe=True)) self.song = event.playbackinfo.song self.paused = event.playbackinfo.ispaused() self.stopped = event.playbackinfo.isstopped() if self.song: self.settitle(u"%s%s" % (event.playbackinfo.iscrossfading() and "-> " or "", self.song.format(self.songformat))) else: self.settitle(_("Playback Info")) self.time = event.playbackinfo.time self.update() # update player info file, if configured if self.playerinfofd: try: self.playerinfofd.seek(0) if self.song: info = "%s - %s (%s/%s)\n" % ( self.song.artist, self.song.title, formattime(self.time), formattime(self.song.length)) else: info = _("Not playing") + "\n" info = encoding.encode(info) self.playerinfofd.write(info) self.playerinfofd.truncate(len(info)) except IOError, e: log.error(_("error '%s' occured during write to playerinfofile") % e) self.playerinfofd = None
def change_wf(self, privkey, hash, diff): y = decode(hash) if diff == 0: return hash if diff > 0: return encode(pow(y, pow(2, diff), self.n)) else: if privkey is None: raise ValueError("Cant decrease without private key") p = privkey.p q = privkey.q ep = sqrtExp(p, -diff) eq = sqrtExp(q, -diff) yp = pow((y % p), ep, p) yq = pow((y % q), eq, q) return encode(chinese_remainder(p, q, privkey.invQ, yp, yq))
def pipeline(host_image, payload_image, encoding_significant_digits, significant_digit_interval): # type: ( # PIL.Image, PIL.Image, int, Tuple[int, int] # ) -> Tuple[PIL.Image, Dict[int, PIL.Image]] """Encodes an image using some params, returning encoded and decoded images. Args: host_image: Host image. payload_image: Payload image. (Yeah, I know, and I don't care. These values are documented elsewhere.) encoding_significant_digits: The significant digits to use in the encoding. significant_digit_interval: The significant digits to scan over when decoding the image. Returns: A 2-tuple; the first item is the encoded image, the second item is a dictionary mapping from significant_digit to decoded PIL.Image. """ encoded = encoding.encode(host_image, payload_image, encoding_significant_digits) return (encoded, processing.process( image=encoded, significant_digit_interval=significant_digit_interval))
def post(self): orig_user = self.request.get("username") username = cgi.escape(orig_user, quote=True) password = cgi.escape(self.request.get("password"), quote=True) name = validate_username(username) passw = validate_password(password) res = { "username": username, "error_name": "" if name else "That's not a valid username.", "password": password, "error_pass": "" if passw else "That wasn't a valid password.", } if name and passw: users = db.GqlQuery("SELECT * FROM User WHERE username=:1", username) correct_passw = "" for user in users: correct_passw = user.password if correct_passw and enc.validate_passw(password, correct_passw): user_key = str(user.key().id()) hidden_key = enc.encode(user_key) cookie_val = str("user_id=%s|%s; Path=/" % (user_key, hidden_key)) self.response.headers.add_header('Set-Cookie', cookie_val) self.redirect('/') elif not correct_passw: res["error_name"] = "User '%s' not registered." % username self.render("login.html", **res) else: res["error_pass"] = "******" self.render("login.html", **res) else: self.render("login.html", **res)
def encode_data_response(data): output = { 'resCode': '9000', 'resMessage': 'OK', 'data': encode(data), } return json.dumps(output)
def read_data_files(data_path, files_destination): letter_indices = make_encodings() os.makedirs(os.path.dirname(files_destination), exist_ok=True) wave_files = [] encoded_labels = [] reader_dirs = os.listdir(data_path) for reader_dir in reader_dirs: chapters_path = data_path + '/' + reader_dir chapter_dirs = os.listdir(chapters_path) for chapter_dir in chapter_dirs: speech_dir = chapters_path + '/' + chapter_dir files = os.listdir(speech_dir) meta_file = list(filter(lambda f: f.endswith('.txt'), files))[0] meta_file_path = speech_dir + '/' + meta_file with open(meta_file_path, 'r') as metafile: for line in metafile: content = line.strip() file, label = content.split(' ', 1) file_path = speech_dir + '/' + file + '.flac' wave_files.append(file_path) encoded_labels.append(encode(label, letter_indices)) return wave_files, encoded_labels
def update(self): if self.playlist.autoplaymode == "repeat": autoplaymode = " [%s]" % _("Repeat") elif self.playlist.autoplaymode == "random": autoplaymode = " [%s]" % _("Random") else: autoplaymode = "" self.settitle("%s (-%s/%s)%s" % (_("Playlist"), formattime((self.playlist.ttime - self.playlist.ptime)), formattime(self.playlist.ttime), autoplaymode)) window.window.update(self) if self.hasfocus(): self.updatestatusbar() for i in range(self.playlist.top, self.playlist.top + self.ih): attr = curses.A_NORMAL if i < len(self.playlist): item = self.playlist[i] if item.playstarttime is not None: h, m, s = time.localtime(item.playstarttime)[3:6] else: h = m = s = 0 adddict = { "playstarthours": h, "playstartminutes": m, "playstartseconds": s } name = encoding.encode( item.song.format(self.songformat, adddict=adddict)) if self.playlist.playingitem and item is self.playlist.playingitem: if self.playlist.selected == i and self.hasfocus(): attr = self.colors.selected_playingsong else: attr = self.colors.playingsong elif item.hasbeenplayed(): if i == self.playlist.selected and self.hasfocus(): attr = self.colors.selected_playedsong else: attr = self.colors.playedsong else: if i == self.playlist.selected and self.hasfocus(): attr = self.colors.selected_unplayedsong else: attr = self.colors.unplayedsong else: name = "" self.addnstr(i - self.playlist.top + self.iy, self.ix, name.ljust(self.iw)[:self.iw], self.iw, attr) self.updatescrollbar() # move cursor to the right position in order to make it more # easy for users of Braille displays to track the current # position/selection if self.hasfocus() and self.playlist.selected is not None: self.win.move(self.playlist.selected - self.playlist.top + 1, 1)
def usage(): print "PyTone %s" % version.version print "Copyright %s" % encoding.encode(version.copyright) print "usage: pytone.py [options]" print "-h, --help: show this help" print "-c, --config <filename>: read config from filename" print "-d, --debug <filename>: enable debugging output (into filename)" print "-r, --rebuild: rebuild all databases"
def __getitem__(self, idx): image_root = self.train_image_file_paths[idx] image_name = image_root.split(os.path.sep)[-1] image = Image.open(image_root) if self.transform is not None: image = self.transform(image) label = ohe.encode(image_name.split('_')[0]) return image, label
def usage(): print("PyTone %s" % version.version) print("Copyright %s" % encoding.encode(version.copyright)) print("usage: pytone.py [options]") print("-h, --help: show this help") print("-c, --config <filename>: read config from filename") print("-d, --debug <filename>: enable debugging output (into filename)") print("-r, --rebuild: rebuild all databases")
def showitems(self): self.clear() try: for lno, line in enumerate(self.lyrics[0][2].split("\n")[self.first:self.first+self.ih]): line = encoding.encode(line).strip().center(self.iw) self.addnstr(self.iy+lno, self.ix, line, self.iw, self.colors.content) except IndexError: pass
def test_encoding(self): input = OrderedDict() input['foo'] = 'bar' input['baz'] = 'qux' input['zap'] = 'zazzle' output = encoding.encode(input) expected = 'foo=bar&baz=qux&zap=zazzle' self.assertEqual(expected, output)
def update(self): if self.title and self.h>=2: if self.hasfocus(): topborder = 0 # uncomment this to get the "thick" border of the old times # topborder = ord("=") attr = self.colors.activeborder try: titleattr = self.colors.activetitle except AttributeError: titleattr = self.colors.title else: topborder = 0 attr = self.colors.border titleattr = self.colors.title # draw configured borders if self.hastopborder(): self.hline(0, self.ix, curses.ACS_HLINE, self.iw, attr) # self.win.border(0, 0, topborder) t = encoding.encode(self.title)[:self.w-4] pos = (self.w-4-len(t))/2 self.addstr(0, pos, "[ %s ]" % t, titleattr) if self.hasleftborder(): self.addch(0, 0, curses.ACS_ULCORNER, attr) if self.hasrightborder(): self.addch(0, self.ix+self.iw, curses.ACS_URCORNER, attr) else: self.addch(0, self.ix+self.iw, curses.ACS_HLINE, attr) else: t = self.title[:self.w] self.addstr(0, 0, t.center(self.w), titleattr) if self.hasbottomborder(): self.hline(self.iy+self.ih, self.ix, curses.ACS_HLINE, self.iw, attr) if self.hasleftborder(): self.addch(self.iy+self.ih, 0, curses.ACS_LLCORNER, attr) if self.hasrightborder(): self.addch(self.iy+self.ih, self.ix+self.iw, curses.ACS_LRCORNER, attr) else: self.addch(self.iy+self.ih, self.ix+self.iw, curses.ACS_HLINE, attr) if self.hasleftborder(): if self.hastopborder(): self.vline(self.iy, 0, curses.ACS_VLINE, self.ih, attr) else: self.vline(0, 0, curses.ACS_VLINE, self.ih+1, attr) if self.hasrightborder(): if self.hastopborder(): self.vline(self.iy, self.ix+self.iw, curses.ACS_VLINE, self.ih, attr) else: self.vline(0, self.ix+self.iw, curses.ACS_VLINE, self.ih+1, attr) # draw additional border elements for y, x, c in self.borderelements: self.addch(y, x, c, attr)
def showitems(self): lines = [] stats = hub.request(requests.getsongdbmanagerstats()) indent = " "*3 for songdbstats in stats.songdbsstats: dbidstring = _("Database %s") % songdbstats.id + ":" dbstatstring = _("%d songs, %d albums, %d artists, %d tags") % (songdbstats.numberofsongs, songdbstats.numberofalbums, songdbstats.numberofartists, songdbstats.numberoftags) lines.append((dbidstring, dbstatstring)) if songdbstats.type == "local": dbtypestring = _("local database (db file: %s)") % (songdbstats.dbfile) else: dbtypestring = _("remote database (server: %s)") % (songdbstats.location) lines.append((indent + _("type") + ":", dbtypestring)) lines.append((indent + _("base directory") + ":", songdbstats.basedir)) dbcachesizestring = "%dkB" % songdbstats.cachesize lines.append((indent + _("cache size") + ":", dbcachesizestring)) lines.append(("", "")) cachestatsstring = _("%d requests, %d / %d objects") % (stats.requestcacherequests, stats.requestcachesize, stats.requestcachemaxsize) if stats.requestcachemaxsize != 0: cachestatsstring = cachestatsstring + " (%d%%)" % (100*stats.requestcachesize//stats.requestcachemaxsize) lines.append((_("Request cache size") + ":", cachestatsstring)) totalrequests = stats.requestcachehits + stats.requestcachemisses if totalrequests != 0: percentstring = " (%d%%)" % (100*stats.requestcachehits//totalrequests) else: percentstring = "" lines.append((_("Request cache stats") + ":", (_("%d hits / %d requests") % (stats.requestcachehits, totalrequests)) + percentstring)) wc1 = max([len(lc) for lc, rc in lines]) + 1 if wc1 > 0.6*self.iw: wc1 = int(0.6*self.iw) wc2 = self.iw - wc1 y = self.iy for lc, rc in lines: self.move(y, self.ix) self.addstr(encoding.encode(lc).ljust(wc1)[:wc1], self.colors.description) self.addstr(encoding.encode(rc).ljust(wc2)[:wc2], self.colors.content) y += 1
def encrypt(filename): encoded_message = "" with open(filename) as file: for word in file.read().split(): message = encode(word) cipher = str(modexp(message, pub_key, n)) encoded_message += cipher + "\r\n" cipher = open("cipher_text", "w+") cipher.write(encoded_message)
def single_test(data, compression, freqs, coding, modulation, **kwargs): enc.encode(data, compression, freqs, coding, modulation, **kwargs) am.playrec('bin.wav', '_bin.wav') ans = dec.decode(len(data), compression, freqs, coding, modulation, **kwargs) # hamming plot_sync plot_main plot_conv error = utils.calc_error_per_freq(data, ans, freqs) if kwargs.get('plot_errors'): utils.plot_smooth_error_graph(data, ans) if list(ans) == list(data): print("YEET!") else: print("S***E") return ans
def update(self): if self.playlist.autoplaymode == "repeat": autoplaymode = " [%s]" % _("Repeat") elif self.playlist.autoplaymode == "random": autoplaymode = " [%s]" % _("Random") else: autoplaymode = "" self.settitle("%s (-%s/%s)%s" % ( _("Playlist"), formattime((self.playlist.ttime- self.playlist.ptime)), formattime(self.playlist.ttime), autoplaymode)) window.window.update(self) if self.hasfocus(): self.updatestatusbar() for i in range(self.playlist.top, self.playlist.top+self.ih): attr = curses.A_NORMAL if i<len(self.playlist): item = self.playlist[i] if item.playstarttime is not None: h, m, s = time.localtime(item.playstarttime)[3:6] else: h = m = s = 0 adddict = {"playstarthours": h, "playstartminutes": m, "playstartseconds": s} name = encoding.encode(item.song.format(self.songformat, adddict=adddict)) if self.playlist.playingitem and item is self.playlist.playingitem: if self.playlist.selected==i and self.hasfocus(): attr = self.colors.selected_playingsong else: attr = self.colors.playingsong elif item.hasbeenplayed(): if i==self.playlist.selected and self.hasfocus(): attr = self.colors.selected_playedsong else: attr = self.colors.playedsong else: if i==self.playlist.selected and self.hasfocus(): attr = self.colors.selected_unplayedsong else: attr = self.colors.unplayedsong else: name = "" self.addnstr(i-self.playlist.top+self.iy, self.ix, name.ljust(self.iw)[:self.iw], self.iw, attr) self.updatescrollbar() # move cursor to the right position in order to make it more # easy for users of Braille displays to track the current # position/selection if self.hasfocus() and self.playlist.selected is not None: self.win.move(self.playlist.selected-self.playlist.top+1, 1)
def __init__(self, n, h=sha256, pre_hashing=True, t=0, w=4096): # The modulus. Let n be a Blum integer, i.e. the product n = pq of two prime integers p and q such that: # p = 3 (mod 4) # q = 3 (mod 4 self.n = n self.preHashing = pre_hashing self.t = t self.h = h self.w = w self.mod_id = self.kdf(encode(n), 8)
def update(self): self.level = self.mixer.get() self.top() window.window.update(self) self.addstr(self.iy, self.ix, encoding.encode(_("Volume:")), self.colors.description) self.addstr(" %3d " % round(self.level[0]), self.colors.content) percent = int(round(self.barlen*self.level[0]/100)) self.addstr("#"*percent, self.colors.barhigh) self.addstr("#"*(self.barlen-percent), self.colors.bar)
def song_list(): last_id = r.get('GLOBAL:last-song-id') result = [] for i in range(last_id): result.append({ 'name': r.get('SONG-NAME:%d' % i), 'id': i }) return encoding.encode(result)
def update(self): self.level = self.mixer.get() self.top() window.window.update(self) self.addstr(self.iy, self.ix, encoding.encode(_("Volume:")), self.colors.description) self.addstr(" %3d " % round(self.level[0]), self.colors.content) percent = int(round(self.barlen * self.level[0] / 100)) self.addstr("#" * percent, self.colors.barhigh) self.addstr("#" * (self.barlen - percent), self.colors.bar)
def join_room(room_id): user_id = generate_id() # TODO grab user name as well r.rpush('ROOM-USERS:%s' % room_id, user_id) r.set('USER-ROOM:%s' % user_id, room_id) r.set('USER-NAME:%s' % user_id, request.args.get('name')) r.set('USER-LAST-ACTIVE:%s' % user_id, int(time.time())) return encoding.encode({'user_id': user_id})
def __init__(self, p, q, gen=None): if p<0 or q <0 or p & 3 != 3 or q & 3 != 3 or p == q: raise ValueError("Invalid Makwa private key") self.p = p self.q = q self.QRGen = gen self.modulus = p*q if len(encode(self.modulus))*8 < 1273: raise ValueError("Invalid Makwa private key") if gen is not None and (gen <= 1 or gen >= self.modulus): raise ValueError("Invalid Makwa private key") self.invQ = modInverse(q, p)
def list_songs(): last_song_id = r.get('GLOBAL:last-song-id') if last_song_id is None: last_song_id = 0 else: last_song_id = int(last_song_id) return encoding.encode([ { 'id': i, 'name': r.get('SONG-NAME:%d' % i).decode('utf-8'), 'credits': r.get('SONG-CREDITS:%d' % i).decode('utf-8') } for i in range(last_song_id) ])
def encodePrivate(p, q, QRGen = None): p_e = encode(p) q_e = encode(q) p_e_len = encode(len(p_e), 2) q_e_len = encode(len(q_e), 2) qrgen_e = None qrgen_e_len = None header = encode(MAGIC_PRIVKEY) if QRGen is not None: qrgen_e = encode(QRGen) qrgen_e_len = encode(len(qrgen_e), 2) header = encode(MAGIC_PRIVKEY_WITHGEN) ret = header + p_e_len + p_e + q_e_len + q_e if QRGen is not None: ret += qrgen_e_len + qrgen_e return ret
def encrypt(input_bytes, key, rounds=5, modulus=DEFAULT_MODULUS): """ usage: encrypt(input_bytes, key, rounds=5, modulus=DEFAULT_MODULUS) => ciphertext Given input_bytes and a key, returns a bytearray of ciphertext. input_bytes and key should be bytearrays. Ciphertexts are partially homomorphic with respect to addition. - Can perform an unlimited number of additions Encrypts 1 byte at a time. Each (2 ** rounds)-bit ciphertext encodes one 8-bit byte. design: iterated randomized encoding (secret sharing) - represent m as r, (m - r) where r is a uniformly random value - doubles message size - apply iteratively until message size == desired key strength - 256 bits of key material requires 256 bits of data to operate upon - Not necessarily true, but keeps it nice and simple - apply 5 rounds to a byte to produce a 8->16->32->64->128->256 bit ciphertext multiplication key addition layer - multiplication instead of addition facilitates performing an arbitrary # of additions - an addition key layer would have to count the # of operations performed - key values must have a multiplicative inverse, which depends upon the modulus used - a modulus of 256 works nicely for 8-bit bytes, but only half the elements have inverses - only using odd key bytes sidesteps the problem, at the expense of -1 bit of security per key byte - could use finite field arithmetic ? """ # encryption process: # encoding step #r1 (m1 - r1) #r2 r3 (r1 - r2) ((m1 - r1) - r3) #r4 r5 r6 r7 (r2 - r4) (r3 - r5) (r1 - r2 - r6) (m1 - r1 - r3 - r7) #r8 r9 r10 r11 r12 r13 r14 r15 (r4 - r8) (r5 - r9) (r6 - 10) (r7 - r11) (r2 - r4 - r12) (r3 - r5 - r13) (r1 - r2 - r6 - r14) (m1 - r1 - r3 - r7 - r15) # key addition step #r8k1 r9k2 r10k3 r11k4 r12k5 r13k6 r14k7 r15k8 (r4k9 - r8k9) (r5k10 - r9k10) (r6k11 - r10k11) (r7k12 - r11k12) (r2k12 - r4k12 - r12k12) (r3k13 - r5k13 - r13k13) (r1k14 - r2k14 - r6k14 - r14k14) (m1k15 - r1k15 - r3k15 - r7k15 - r15k15) output = [] for byte in input_bytes: data = [byte] for round in range(rounds): data[:] = encode(data, modulus) multiplication_subroutine(data, [item | 1 for item in key], modulus) assert len(data) == 2 ** rounds, (len(data), 2 ** rounds) output.extend(data[:]) return output
def update(self): self.settitle(self.items.selectionpath()) window.window.update(self) if self.hasfocus(): self.updatestatusbar() showselectionbar = self.hasfocus() or self.searchpositions for i in range(self.items.top, self.items.top+self.ih): attr = curses.A_NORMAL if i<len(self.items): aitem = self.items[i] name = self.items[i].getname() if isinstance(aitem, item.song): if i==self.items.selected and showselectionbar: attr = self.colors.selected_song else: attr = self.colors.song elif isinstance(aitem, (item.artist, item.album)): if i==self.items.selected and showselectionbar: attr = self.colors.selected_artist_album else: attr = self.colors.artist_album else: if i==self.items.selected and showselectionbar: attr = self.colors.selected_directory else: attr = self.colors.directory else: name = "" name = encoding.encode(name) self.addstr(i-self.items.top+self.iy, self.ix, name.ljust(self.iw)[:self.iw], attr) self.updatescrollbar() # move cursor to the right position in order to make it more # easy for users of Braille displays to track the current # position/selection if self.hasfocus() and self.items.selected is not None: self.win.move(self.items.selected-self.items.top+1, 1)
def encoding_delegate(image, channels, *args): """ Will need to get an array that contains: 1. a value informing what encoding is needed. 2. an array of values to encode. Assuming RGB values. Will return an array with encoded values. """ channels = [[int(r) for r in channel] for channel in channels] scheme = None while scheme is None: scheme_input = raw_input("Choose encoding scheme (2: Shannon Fanno, 3: LZW): ") if not scheme_input: break try: scheme_int = int(scheme_input) except ValueError: print("Invalid input") continue if scheme_int not in (1, 2, 3): print("Invalid input") continue scheme = scheme_int t5_output = channels t5_output = [encoding.encode(channel, scheme) for channel in t5_output] # t5_output = [encoding.decode(enc, scheme) for enc in t5_output] t5_output = bin_seq_to_bytearray(''.join(t5_output)) return t5_output
def fetchMails(args): # fetch emails: m = createMailer() mails = m.fetchMails() # connect to database & get enabled email addresses: db = connectToDatabase() addresses = db.getEnabledAddresses() # create message generator: messages = createMessageGenerator() # check received mails: for mail in mails: # validate sender: fromAddr = email.utils.parseaddr(mail['From']) sender = fromAddr[1].strip().lower() if sender in addresses: # parse email: subject = mail['Subject'].lower().strip() if subject == 'tweet': action = database.PUBLISH_TWEET elif subject == 'follow': action = database.FOLLOW_USER elif subject == 'unfollow': action = database.UNFOLLOW_USER else: action = -1 if action <> -1: date = time.mktime(email.utils.parsedate(mail['Date'])) if mail.is_multipart(): body = mail.get_payload(0).get_payload().strip() else: body = mail.get_payload().strip() body = trimBody(encode(decodestring(body))) m = re.match('^<html>.*', body) if not m is None: r = createHtmlRenderer() body = r.render(body) # validate body & append message to queue on success: if action == database.PUBLISH_TWEET: if len(body) < 5: db.createMessage(addresses[sender], messages.tweetTooShort(body)) elif len(body) > 140: db.createMessage(addresses[sender], messages.tweetTooLong(body)) else: db.createMessage(addresses[sender], messages.tweetAccepted(body)) db.appendToQueue(addresses[sender], action, body, date, time.time()) else: for username in [u.strip() for u in body.split(',')]: if len(username) < 3 or len(username) > 24: if action == database.FOLLOW_USER: db.createMessage(addresses[sender], messages.followNotAccepted(username)) else: db.createMessage(addresses[sender], messages.unfollowNotAccepted(username)) else: if action == database.FOLLOW_USER: db.createMessage(addresses[sender], messages.followAccepted(username)) else: db.createMessage(addresses[sender], messages.unfollowAccepted(username)) db.appendToQueue(addresses[sender], action, username, date, time.time())
def changetermtitle(self, event): prefix = (event.playbackinfo.iscrossfading() and '-> ' or '') song = encoding.encode(event.playbackinfo.song.format(self.config.songformat, safe=True)) sys.stdout.write('\033]0;' + prefix + song + '\007')
def update(self): # update window title aitem = self.items[self.activeview] title = _("No song") if isinstance(aitem, (item.song, services.playlist.playlistitem)): if isinstance(aitem, item.song): atype = aitem.type else: atype = aitem.song.type if atype == "mp3": title = _("MP3 Info") elif atype == "ogg": title = _("Ogg Info") else: title = _("Song Info") elif isinstance(aitem, item.diritem): title = _("Directory Info") if self.activeview != selection: title = title + " " + _("[Player: %s]") % self.activeview self.settitle(title) window.window.update(self) # get lines to display empty= [["", "", "", ""]] if aitem is not None: info = aitem.getinfo() else: info = [] l = info + empty*(4-len(info)) colsep = self.iw > 45 # calculate width of columns wc1 = max( len(l[0][0]), len(l[1][0]), len(l[2][0]), len(l[3][0])) + colsep wc3 = max( len(l[0][2]), len(l[1][2]), len(l[2][2])) + colsep wc4 = 5 wc4 = max( len(l[0][3]), len(l[1][3]), len(l[2][3])) wc2 = self.iw-wc1-wc3-wc4-1 for lno in range(4): self.move(1+lno, self.ix) l0 = encoding.encode(l[lno][0]) l1 = encoding.encode(l[lno][1]) self.addstr(l0.ljust(wc1)[:wc1], self.colors.description) self.addstr(l1.ljust(wc2)[:wc2], self.colors.content) self.addch(" ") if lno != 3 or isinstance(aitem, item.diritem): l2 = encoding.encode(l[lno][2]) l3 = encoding.encode(l[lno][3]) self.addstr(l2.ljust(wc3)[:wc3], self.colors.description) self.addstr(l3.ljust(wc4)[:wc4], self.colors.content) else: l2 = encoding.encode(l[3][-2]) l3 = encoding.encode(l[3][-1]) # special handling of last line for songs wc3 = max(len(l2), 5) + colsep wc4 = max(len(l3), 5) self.move(1+lno, self.iw-wc3-wc4-1-self.ix) self.addch(" ") self.addstr(l2.ljust(wc3)[:wc3], self.colors.description) self.addstr(l3.ljust(wc4)[:wc4], self.colors.content)
import encoding import protein_translation import sys switch = sys.argv[1] filename = sys.argv[2] with open(filename, 'r') as f: if switch == 'encoding': text = f.readline().strip() peptide = f.readline().strip() print('\n'.join(encoding.encode(text, peptide))) else: input = f.readline().strip() print(protein_translation.translate(input))
from encoding import encode from decoding import decode from additional import create_argument_parser parser = create_argument_parser() args = parser.parse_args() if not args.encode is None: encode(args.encode[0], args.encode[1], args.encode[2], args.bit_count) elif not args.decode is None: decode(args.decode[0], args.decode[1]) else: print("You don't specified neither -e nor -d option") exit(1)
def playbackinfochanged(self, event): if event.playbackinfo.song and event.playbackinfo.song != self.previoussong: song = encoding.encode(event.playbackinfo.song.format(self.config.songformat, safe=True)) os.system('echo "%s" | %s &' % (song, self.command)) self.previoussong = event.playbackinfo.song