apppublic/appPublic/rc4.py

250 lines
8.4 KiB
Python
Raw Normal View History

2019-07-16 16:33:07 +08:00
# -*- coding: utf-8 -*-
import random, base64
from hashlib import sha1
class RC4:
def __init__(self,key='1234567890',data_coding='utf8'):
self.bcoding = 'iso-8859-1'
self.dcoding = data_coding
self.key = key.encode(self.bcoding)
self.salt = b'AFUqx9WZuI32lnHk'
def _crypt(self,data,key):
"""RC4 algorithm return bytes"""
if type(data)==type(''):
data = data.encode(self.dcoding)
x = 0
box = [i for i in range(256) ]
for i in range(256):
x = (x + box[i] + key[i % len(key)]) % 256
box[i], box[x] = box[x], box[i]
x = y = 0
out = []
for char in data:
x = (x + 1) % 256
y = (y + box[x]) % 256
box[x], box[y] = box[y], box[x]
out.append(chr(char ^ box[(box[x] + box[y]) % 256]))
return ''.join(out).encode(self.bcoding)
def encode(self,data, encode=base64.b64encode, salt_length=16):
"""RC4 encryption with random salt and final encoding"""
#salt = ''
#for n in range(salt_length):
# salt += chr(random.randrange(256))
#salt = salt.encode(self.bcoding)
a = sha1(self.key + self.salt)
k = a.digest()
data = self.salt + self._crypt(data, k)
if encode:
data = encode(data)
return data.decode(self.dcoding)
def decode(self,data, decode=base64.b64decode, salt_length=16):
"""RC4 decryption of encoded data"""
if decode:
data = decode(data)
salt = data[:salt_length]
a = sha1(self.key + self.salt)
k = a.digest() #.decode('iso-8859-1')
r = self._crypt(data[salt_length:], k)
return r.decode(self.dcoding)
if __name__=='__main__':
# 需要加密的数据
data = '''hello python 爱的实打实大师大师大师的发送到发送到而非个人格个二哥而而二哥而个人各位,UDP是一种无连接对等通信协议没有服务器和客户端概念通信的任何一方均可通过通信原语直接和其他方通信
HOME FAQ DOCS DOWNLOAD
index
next |
previous |
Twisted 18.9.0 documentation » Twisted Names (DNS) » Developer Guides »
Creating a custom server
The builtin DNS server plugin is useful, but the beauty of Twisted Names is that you can build your own custom servers and clients using the names components.
In this section you will learn about the components required to build a simple DNS server.
You will then learn how to create a custom DNS server which calculates responses dynamically.
A simple forwarding DNS server
Lets start by creating a simple forwarding DNS server, which forwards all requests to an upstream server (or servers).
simple_server.py
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
An example of a simple non-authoritative DNS server.
"""
from twisted.internet import reactor
from twisted.names import client, dns, server
def main():
"""
Run the server.
"""
factory = server.DNSServerFactory(
clients=[client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(10053, protocol)
reactor.listenTCP(10053, factory)
reactor.run()
if __name__ == '__main__':
raise SystemExit(main())
In this example we are passing a client.Resolver instance to the DNSServerFactory and we are configuring that client to use the upstream DNS servers which are specified in a local resolv.conf file.
Also note that we start the server listening on both UDP and TCP ports. This is a standard requirement for DNS servers.
You can test the server using dig. For example:
$ dig -p 10053 @127.0.0.1 example.com SOA +short
sns.dns.icann.org. noc.dns.icann.org. 2013102791 7200 3600 1209600 3600
A server which computes responses dynamically
Now suppose we want to create a bespoke DNS server which responds to certain hostname queries by dynamically calculating the resulting IP address, while passing all other queries to another DNS server. Queries for hostnames matching the pattern workstation{0-9}+ will result in an IP address where the last octet matches the workstation number.
Well write a custom resolver which we insert before the standard client resolver. The custom resolver will be queried first.
Heres the code:
override_server.py
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
An example demonstrating how to create a custom DNS server.
The server will calculate the responses to A queries where the name begins with
the word "workstation".
Other queries will be handled by a fallback resolver.
eg
python doc/names/howto/listings/names/override_server.py
$ dig -p 10053 @localhost workstation1.example.com A +short
172.0.2.1
"""
from twisted.internet import reactor, defer
from twisted.names import client, dns, error, server
class DynamicResolver(object):
"""
A resolver which calculates the answers to certain queries based on the
query type and name.
"""
_pattern = 'workstation'
_network = '172.0.2'
def _dynamicResponseRequired(self, query):
"""
Check the query to determine if a dynamic response is required.
"""
if query.type == dns.A:
labels = query.name.name.split('.')
if labels[0].startswith(self._pattern):
return True
return False
def _doDynamicResponse(self, query):
"""
Calculate the response to a query.
"""
name = query.name.name
labels = name.split('.')
parts = labels[0].split(self._pattern)
lastOctet = int(parts[1])
answer = dns.RRHeader(
name=name,
payload=dns.Record_A(address=b'%s.%s' % (self._network, lastOctet)))
answers = [answer]
authority = []
additional = []
return answers, authority, additional
def query(self, query, timeout=None):
"""
Check if the query should be answered dynamically, otherwise dispatch to
the fallback resolver.
"""
if self._dynamicResponseRequired(query):
return defer.succeed(self._doDynamicResponse(query))
else:
return defer.fail(error.DomainError())
def main():
"""
Run the server.
"""
factory = server.DNSServerFactory(
clients=[DynamicResolver(), client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(10053, protocol)
reactor.listenTCP(10053, factory)
reactor.run()
if __name__ == '__main__':
raise SystemExit(main())
Notice that DynamicResolver.query returns a Deferred. On success, it returns three lists of DNS records (answers, authority, additional), which will be encoded by dns.Message and returned to the client. On failure, it returns a DomainError, which is a signal that the query should be dispatched to the next client resolver in the list.
Note
The fallback behaviour is actually handled by ResolverChain.
ResolverChain is a proxy for other resolvers. It takes a list of IResolver providers and queries each one in turn until it receives an answer, or until the list is exhausted.
Each IResolver in the chain may return a deferred DomainError, which is a signal that ResolverChain should query the next chained resolver.
The DNSServerFactory constructor takes a list of authoritative resolvers, caches and client resolvers and ensures that they are added to the ResolverChain in the correct order.
Lets use dig to see how this server responds to requests that match the pattern we specified:
$ dig -p 10053 @127.0.0.1 workstation1.example.com A +short
172.0.2.1
$ dig -p 10053 @127.0.0.1 workstation100.example.com A +short
172.0.2.100
And if we issue a request that doesnt match the pattern:
$ dig -p 10053 @localhost www.example.com A +short
93.184.216.119
Further Reading
For simplicity, the examples above use the reactor.listenXXX APIs. But your application will be more flexible if you use the Twisted Application APIs, along with the Twisted plugin system and twistd. Read the source code of names.tap to see how the twistd names plugin works.
Table Of Contents
Creating a custom server
A simple forwarding DNS server
A server which computes responses dynamically
Further Reading
Previous topic
Creating and working with a names (DNS) server
Next topic
Examples
This Page
Show Source
Quick search
Enter search terms or a module, class or function name.
Site design
By huw.wilkins.
'''
# 密钥
key = '123456'
rc4 = RC4(key)
print(data)
# 加码
encoded_data = rc4.encode(data)
print(encoded_data,len(encoded_data) )
# 解码
decoded_data = rc4.decode(encoded_data)
print(decoded_data)