├── LICENSE.txt
├── PKG-INFO
├── README.md
├── agora_token_builder.egg-info
    ├── PKG-INFO
    ├── SOURCES.txt
    ├── dependency_links.txt
    └── top_level.txt
├── agora_token_builder
    ├── AccessToken.py
    ├── RtcTokenBuilder.py
    ├── RtmTokenBuilder.py
    └── __init__.py
├── dist
    └── agora_token_builder-1.0.0.tar.gz
├── setup.cfg
└── setup.py


/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | Copyright (c) 2021 Agora.io
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining a copy
 5 | of this software and associated documentation files (the "Software"), to deal
 6 | in the Software without restriction, including without limitation the rights
 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the Software is
 9 | furnished to do so, subject to the following conditions:
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
15 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
17 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
18 | SOFTWARE.


--------------------------------------------------------------------------------
/PKG-INFO:
--------------------------------------------------------------------------------
 1 | Metadata-Version: 2.1
 2 | Name: agora_token_builder
 3 | Version: 2.2.5
 4 | Summary: Agora Token Builder. RTC & RTM
 5 | Home-page: UNKNOWN
 6 | Author: Dennis
 7 | Author-email: <dennis@agora.io>
 8 | License: UNKNOWN
 9 | Keywords: python,agora,token-builder
10 | Platform: UNKNOWN
11 | Classifier: Development Status :: 1 - Planning
12 | Classifier: Intended Audience :: Developers
13 | Classifier: Programming Language :: Python :: 3
14 | Classifier: Operating System :: Unix
15 | Classifier: Operating System :: MacOS :: MacOS X
16 | Classifier: Operating System :: Microsoft :: Windows
17 | Description-Content-Type: text/markdown
18 | License-File: LICENSE.txt
19 | 
20 | # Agora Token Generator
21 | 
22 | 
23 | # Description 
24 | Token generator for building a token server with Python & the Agora RTM & RTC
25 | 
26 | ## Installation
27 | ```pip install agora-token-builder```
28 | 
29 | ## How to use it?
30 | 
31 | ###### Importing for RTC
32 | ```from agora_token_builder import RtcTokenBuilder```
33 | 
34 | ###### Importing for RTM
35 | ```from agora_token_builder import RtmTokenBuilder```
36 | 
37 | ## License
38 | 
39 | © 2021 Agora.io
40 | 
41 | This repository is licensed under the MIT license. See LICENSE for details.
42 | 
43 | 
44 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Agora Token Generator
 2 | 
 3 | 
 4 | # Description 
 5 | Token generator for building a token server with Python & the Agora RTM/RTC
 6 | 
 7 | ## Installation
 8 | ------------
 9 | 
10 | ```pip install agora-token-builder```
11 | 
12 | ## Usage
13 | ------------
14 | 
15 | ###### RTC Live Video Calling & Chat SDK
16 | 
17 | Build token with `int` UID:
18 | ```python
19 | from agora_token_builder import RtcTokenBuilder
20 | 
21 | #Build token with uid
22 | token = RtcTokenBuilder.buildTokenWithUid(appId, appCertificate, channelName, uid, role, privilegeExpiredTs)
23 | ```
24 | Build token with `string` UserAccount:
25 | ```python
26 | from agora_token_builder import RtcTokenBuilder
27 | 
28 | #Build token with userAccount
29 | token = RtcTokenBuilder.buildTokenWithAccount(appId, appCertificate, channelName, account, role, privilegeExpiredTs)
30 | ```
31 | 
32 | ###### RTM Real-Time Messaging & Chat SDK
33 | Build RTM token.
34 | ```python
35 | from agora_token_builder import RtmTokenBuilder
36 | 
37 | token = RtmTokenBuilder.buildToken(appID, appCertificate, userAccount, role, privilegeExpiredTs)
38 | ```
39 | 
40 | 
41 | 
42 | ## Variable Definitions
43 | 
44 | ```appID```
45 | <br>
46 | The App ID issued to you by Agora. Apply for a new App ID from the gora Dashboard if it is missing from your kit. See Get an App ID.
47 | 
48 | ```appCertificate```
49 | <br>
50 | 	Certificate of the application that you registered in the Agora Dashboard. See Get an App Certificate.
51 | 
52 | ```channelName```
53 | <br>
54 | Unique channel name for the AgoraRTC session in the string format
55 | 
56 | ```uid```
57 | <br>
58 | User ID. A 32-bit unsigned integer with a value ranging from 1 to (232-1). optionalUid must be unique.
59 | 
60 | ```userAccount```
61 | A unique identifier used for to represent a user account. This value will be a string and can contain numbers, letters and any special characters.  
62 | 
63 | ```role```
64 | <br>
65 | Role_Publisher = 1: A broadcaster (host) in a live-broadcast profile. Role_Subscriber = 2: (Default) A audience in a live-broadcast profile.
66 | 
67 | ```privilegeExpireTs```
68 | <br>
69 | Represented by the number of seconds elapsed since 1/1/1970. If, for example, you want to access the Agora Service within 10 minutes after the token is generated, set expireTimestamp as the current
70 | 
71 | 
72 | ## License
73 | 
74 | © 2021 Agora.io
75 | 
76 | This repository is licensed under the MIT license. See LICENSE for details.
77 | 


--------------------------------------------------------------------------------
/agora_token_builder.egg-info/PKG-INFO:
--------------------------------------------------------------------------------
 1 | Metadata-Version: 2.1
 2 | Name: agora-token-builder
 3 | Version: 1.0.0
 4 | Summary: Agora Token Builder. RTC & RTM
 5 | Home-page: https://github.com/AgoraIO-Community/python-token-builder
 6 | Author: Dennis
 7 | Author-email: <dennis@agora.io>
 8 | License: UNKNOWN
 9 | Keywords: python,agora,token-builder
10 | Platform: UNKNOWN
11 | Classifier: Development Status :: 1 - Planning
12 | Classifier: Intended Audience :: Developers
13 | Classifier: Programming Language :: Python :: 3
14 | Description-Content-Type: text/markdown
15 | License-File: LICENSE.txt
16 | 
17 | # Agora Token Generator
18 | 
19 | 
20 | # Description 
21 | Token generator for building a token server with Python & the Agora RTM/RTC
22 | 
23 | ## Installation
24 | ------------
25 | 
26 | ```pip install agora-token-builder```
27 | 
28 | ## Usage
29 | ------------
30 | 
31 | ###### RTC Live Video Calling & Chat SDK
32 | 
33 | Build token with `int` UID:
34 | ```python
35 | from agora_token_builder import RtcTokenBuilder
36 | 
37 | #Build token with uid
38 | token = RtcTokenBuilder.buildTokenWithUid(appId, appCertificate, channelName, uid, role, privilegeExpiredTs)
39 | ```
40 | Build token with `string` UserAccount:
41 | ```python
42 | from agora_token_builder import RtcTokenBuilder
43 | 
44 | #Build token with userAccount
45 | token = RtcTokenBuilder.buildTokenWithAccount(appId, appCertificate, channelName, account, role, privilegeExpiredTs)
46 | ```
47 | 
48 | ###### RTM Real-Time Messaging & Chat SDK
49 | Build RTM token.
50 | ```python
51 | from agora_token_builder import RtmTokenBuilder
52 | 
53 | token = RtmTokenBuilder.buildToken(appID, appCertificate, userAccount, role, privilegeExpiredTs)
54 | ```
55 | 
56 | 
57 | 
58 | ## Variable Definitions
59 | 
60 | ```appID```
61 | <br>
62 | The App ID issued to you by Agora. Apply for a new App ID from the gora Dashboard if it is missing from your kit. See Get an App ID.
63 | 
64 | ```appCertificate```
65 | <br>
66 | 	Certificate of the application that you registered in the Agora Dashboard. See Get an App Certificate.
67 | 
68 | ```channelName```
69 | <br>
70 | Unique channel name for the AgoraRTC session in the string format
71 | 
72 | ```uid```
73 | <br>
74 | User ID. A 32-bit unsigned integer with a value ranging from 1 to (232-1). optionalUid must be unique.
75 | 
76 | ```userAccount```
77 | A unique identifier used for to represent a user account. This value will be a string and can contain numbers, letters and any special characters.  
78 | 
79 | ```role```
80 | <br>
81 | Role_Publisher = 1: A broadcaster (host) in a live-broadcast profile. Role_Subscriber = 2: (Default) A audience in a live-broadcast profile.
82 | 
83 | ```privilegeExpireTs```
84 | <br>
85 | Represented by the number of seconds elapsed since 1/1/1970. If, for example, you want to access the Agora Service within 10 minutes after the token is generated, set expireTimestamp as the current
86 | 
87 | 
88 | ## License
89 | 
90 | © 2021 Agora.io
91 | 
92 | This repository is licensed under the MIT license. See LICENSE for details.
93 | 
94 | 
95 | 


--------------------------------------------------------------------------------
/agora_token_builder.egg-info/SOURCES.txt:
--------------------------------------------------------------------------------
 1 | LICENSE.txt
 2 | README.md
 3 | setup.cfg
 4 | setup.py
 5 | agora_token_builder/AccessToken.py
 6 | agora_token_builder/RtcTokenBuilder.py
 7 | agora_token_builder/RtmTokenBuilder.py
 8 | agora_token_builder/__init__.py
 9 | agora_token_builder.egg-info/PKG-INFO
10 | agora_token_builder.egg-info/SOURCES.txt
11 | agora_token_builder.egg-info/dependency_links.txt
12 | agora_token_builder.egg-info/top_level.txt


--------------------------------------------------------------------------------
/agora_token_builder.egg-info/dependency_links.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/agora_token_builder.egg-info/top_level.txt:
--------------------------------------------------------------------------------
1 | agora_token_builder
2 | 


--------------------------------------------------------------------------------
/agora_token_builder/AccessToken.py:
--------------------------------------------------------------------------------
  1 | import hmac
  2 | from hashlib import sha256
  3 | import base64
  4 | import struct
  5 | from zlib import crc32
  6 | import secrets
  7 | import time
  8 | from collections import OrderedDict
  9 | 
 10 | kJoinChannel = 1
 11 | kPublishAudioStream = 2
 12 | kPublishVideoStream = 3
 13 | kPublishDataStream = 4
 14 | kRtmLogin = 1000
 15 | 
 16 | VERSION_LENGTH = 3
 17 | APP_ID_LENGTH = 32
 18 | 
 19 | 
 20 | def getVersion():
 21 |     return '006'
 22 | 
 23 | 
 24 | def packUint16(x):
 25 |     return struct.pack('<H', int(x))
 26 | 
 27 | 
 28 | def packUint32(x):
 29 |     return struct.pack('<I', int(x))
 30 | 
 31 | 
 32 | def packInt32(x):
 33 |     return struct.pack('<i', int(x))
 34 | 
 35 | 
 36 | def packString(string):
 37 |     return packUint16(len(string)) + string
 38 | 
 39 | 
 40 | def packMap(m):
 41 |     ret = packUint16(len(list(m.items())))
 42 |     for k, v in list(m.items()):
 43 |         ret += packUint16(k) + packString(v)
 44 |     return ret
 45 | 
 46 | 
 47 | def packMapUint32(m):
 48 |     ret = packUint16(len(list(m.items())))
 49 |     for k, v in list(m.items()):
 50 |         ret += packUint16(k) + packUint32(v)
 51 |     return ret
 52 | 
 53 | 
 54 | class ReadByteBuffer:
 55 | 
 56 |     def __init__(self, bytes):
 57 |         self.buffer = bytes
 58 |         self.position = 0
 59 | 
 60 |     def unPackUint16(self):
 61 |         len = struct.calcsize('H')
 62 |         buff = self.buffer[self.position: self.position + len]
 63 |         ret = struct.unpack('<H', buff)[0]
 64 |         self.position += len
 65 |         return ret
 66 | 
 67 |     def unPackUint32(self):
 68 |         len = struct.calcsize('I')
 69 |         buff = self.buffer[self.position: self.position + len]
 70 |         ret = struct.unpack('<I', buff)[0]
 71 |         self.position += len
 72 |         return ret
 73 | 
 74 |     def unPackString(self):
 75 |         strlen = self.unPackUint16()
 76 |         buff = self.buffer[self.position: self.position + strlen]
 77 |         ret = struct.unpack('<' + str(strlen) + 's', buff)[0]
 78 |         self.position += strlen
 79 |         return ret
 80 | 
 81 |     def unPackMapUint32(self):
 82 |         messages = {}
 83 |         maplen = self.unPackUint16()
 84 | 
 85 |         for index in range(maplen):
 86 |             key = self.unPackUint16()
 87 |             value = self.unPackUint32()
 88 |             messages[key] = value
 89 |         return messages
 90 | 
 91 | 
 92 | def unPackContent(buff):
 93 |     readbuf = ReadByteBuffer(buff)
 94 |     signature = readbuf.unPackString()
 95 |     crc_channel_name = readbuf.unPackUint32()
 96 |     crc_uid = readbuf.unPackUint32()
 97 |     m = readbuf.unPackString()
 98 | 
 99 |     return signature, crc_channel_name, crc_uid, m
100 | 
101 | 
102 | def unPackMessages(buff):
103 |     readbuf = ReadByteBuffer(buff)
104 |     salt = readbuf.unPackUint32()
105 |     ts = readbuf.unPackUint32()
106 |     messages = readbuf.unPackMapUint32()
107 | 
108 |     return salt, ts, messages
109 | 
110 | 
111 | class AccessToken:
112 | 
113 |     def __init__(self, appID='', appCertificate='', channelName='', uid=''):
114 |         self.appID = appID
115 |         self.appCertificate = appCertificate
116 |         self.channelName = channelName
117 |         self.ts = int(time.time()) + 24 * 3600
118 |         self.salt = secrets.SystemRandom().randint(1, 99999999)
119 |         self.messages = {}
120 |         if (uid == 0):
121 |             self.uidStr = ""
122 |         else:
123 |             self.uidStr = str(uid)
124 | 
125 |     def addPrivilege(self, privilege, expireTimestamp):
126 |         self.messages[privilege] = expireTimestamp
127 | 
128 |     def fromString(self, originToken):
129 |         try:
130 |             dk6version = getVersion()
131 |             originVersion = originToken[:VERSION_LENGTH]
132 |             if (originVersion != dk6version):
133 |                 return False
134 | 
135 |             originAppID = originToken[VERSION_LENGTH:(VERSION_LENGTH + APP_ID_LENGTH)]
136 |             originContent = originToken[(VERSION_LENGTH + APP_ID_LENGTH):]
137 |             originContentDecoded = base64.b64decode(originContent)
138 | 
139 |             signature, crc_channel_name, crc_uid, m = unPackContent(originContentDecoded)
140 |             self.salt, self.ts, self.messages = unPackMessages(m)
141 | 
142 |         except Exception as e:
143 |             print("error:", str(e))
144 |             return False
145 | 
146 |         return True
147 | 
148 |     def build(self):
149 | 
150 |         self.messages = OrderedDict(sorted(iter(self.messages.items()), key=lambda x: int(x[0])))
151 | 
152 |         m = packUint32(self.salt) + packUint32(self.ts) \
153 |             + packMapUint32(self.messages)
154 | 
155 |         val = self.appID.encode('utf-8') + self.channelName.encode('utf-8') + self.uidStr.encode('utf-8') + m
156 | 
157 |         signature = hmac.new(self.appCertificate.encode('utf-8'), val, sha256).digest()
158 |         crc_channel_name = crc32(self.channelName.encode('utf-8')) & 0xffffffff
159 |         crc_uid = crc32(self.uidStr.encode('utf-8')) & 0xffffffff
160 | 
161 |         content = packString(signature) \
162 |                   + packUint32(crc_channel_name) \
163 |                   + packUint32(crc_uid) \
164 |                   + packString(m)
165 | 
166 |         version = getVersion()
167 |         ret = version + self.appID + base64.b64encode(content).decode('utf-8')
168 |         return ret


--------------------------------------------------------------------------------
/agora_token_builder/RtcTokenBuilder.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import sys
 3 | from collections import OrderedDict
 4 | 
 5 | from .AccessToken import *
 6 | 
 7 | Role_Attendee = 0  # depreated, same as publisher
 8 | Role_Publisher = 1  # for live broadcaster
 9 | Role_Subscriber = 2  # default, for live audience
10 | Role_Admin = 101  # deprecated, same as publisher
11 | 
12 | 
13 | class RtcTokenBuilder:
14 |     # appID: The App ID issued to you by Agora. Apply for a new App ID from
15 |     #        Agora Dashboard if it is missing from your kit. See Get an App ID.
16 |     # appCertificate:	Certificate of the application that you registered in
17 |     #                  the Agora Dashboard. See Get an App Certificate.
18 |     # channelName:Unique channel name for the AgoraRTC session in the string format
19 |     # uid: User ID. A 32-bit unsigned integer with a value ranging from
20 |     #      1 to (232-1). optionalUid must be unique.
21 |     # role: Role_Publisher = 1: A broadcaster (host) in a live-broadcast profile.
22 |     #       Role_Subscriber = 2: (Default) A audience in a live-broadcast profile.
23 |     # privilegeExpireTs: represented by the number of seconds elapsed since
24 |     #                    1/1/1970. If, for example, you want to access the
25 |     #                    Agora Service within 10 minutes after the token is
26 |     #                    generated, set expireTimestamp as the current
27 |     #                    timestamp + 600 (seconds)./
28 |     @staticmethod
29 |     def buildTokenWithUid(appId, appCertificate, channelName, uid, role, privilegeExpiredTs):
30 |         return RtcTokenBuilder.buildTokenWithAccount(appId, appCertificate, channelName, uid, role, privilegeExpiredTs)
31 | 
32 |     # appID: The App ID issued to you by Agora. Apply for a new App ID from
33 |     #        Agora Dashboard if it is missing from your kit. See Get an App ID.
34 |     # appCertificate:	Certificate of the application that you registered in
35 |     #                  the Agora Dashboard. See Get an App Certificate.
36 |     # channelName:Unique channel name for the AgoraRTC session in the string format
37 |     # userAccount: The user account.
38 |     # role: Role_Publisher = 1: A broadcaster (host) in a live-broadcast profile.
39 |     #       Role_Subscriber = 2: (Default) A audience in a live-broadcast profile.
40 |     # privilegeExpireTs: represented by the number of seconds elapsed since
41 |     #                    1/1/1970. If, for example, you want to access the
42 |     #                    Agora Service within 10 minutes after the token is
43 |     #                    generated, set expireTimestamp as the current
44 |     @staticmethod
45 |     def buildTokenWithAccount(appId, appCertificate, channelName, account, role, privilegeExpiredTs):
46 |         token = AccessToken(appId, appCertificate, channelName, account)
47 |         token.addPrivilege(kJoinChannel, privilegeExpiredTs)
48 |         if (role == Role_Attendee) | (role == Role_Admin) | (role == Role_Publisher):
49 |             token.addPrivilege(kPublishVideoStream, privilegeExpiredTs)
50 |             token.addPrivilege(kPublishAudioStream, privilegeExpiredTs)
51 |             token.addPrivilege(kPublishDataStream, privilegeExpiredTs)
52 |         return token.build()
53 | 


--------------------------------------------------------------------------------
/agora_token_builder/RtmTokenBuilder.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | 
 4 | from .AccessToken import *
 5 | # Just adding a comment for testing
 6 | Role_Rtm_User = 1
 7 | 
 8 | 
 9 | class RtmTokenBuilder:
10 |     # appID: The App ID issued to you by Agora. Apply for a new App ID from
11 |     #        Agora Dashboard if it is missing from your kit. See Get an App ID.
12 |     # appCertificate:	Certificate of the application that you registered in
13 |     #                  the Agora Dashboard. See Get an App Certificate.
14 |     # userAccount: The user account.
15 |     # role: Role_Rtm_User = 1
16 |     # privilegeExpireTs: represented by the number of seconds elapsed since
17 |     #                    1/1/1970. If, for example, you want to access the
18 |     #                    Agora Service within 10 minutes after the token is
19 |     #                    generated, set expireTimestamp as the current
20 |     #                    timestamp + 600 (seconds)./
21 |     @staticmethod
22 |     def buildToken(appId, appCertificate, userAccount, role, privilegeExpiredTs):
23 |         token = AccessToken(appId, appCertificate, userAccount, "")
24 |         token.addPrivilege(kRtmLogin, privilegeExpiredTs)
25 |         return token.build()
26 | 


--------------------------------------------------------------------------------
/agora_token_builder/__init__.py:
--------------------------------------------------------------------------------
1 | from agora_token_builder.RtcTokenBuilder import RtcTokenBuilder
2 | from agora_token_builder.RtmTokenBuilder import RtmTokenBuilder


--------------------------------------------------------------------------------
/dist/agora_token_builder-1.0.0.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AgoraIO-Community/python-token-builder/bd87fcf1cba7648ca2dac853cafd08db6bf40b4d/dist/agora_token_builder-1.0.0.tar.gz


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | description-file = README.md
3 | 
4 | [egg_info]
5 | tag_build = 
6 | tag_date = 0
7 | 
8 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | import codecs
 3 | import os
 4 | import pathlib
 5 | 
 6 | VERSION = '1.0.0'
 7 | DESCRIPTION = 'Agora Token Builder. RTC & RTM'
 8 | LONG_DESCRIPTION = ''
 9 | 
10 | HERE = pathlib.Path(__file__).parent
11 | 
12 | README = (HERE / "README.md").read_text()
13 | 
14 | # Setting up
15 | setup(
16 |     name="agora_token_builder",
17 |     version=VERSION,
18 |     author="Dennis",
19 |     author_email="<dennis@agora.io>",
20 |     description=DESCRIPTION,
21 |     long_description_content_type="text/markdown",
22 |     long_description=README,
23 |     url="https://github.com/AgoraIO-Community/python-token-builder",
24 |     packages=find_packages(),
25 |     install_requires=[],
26 |     keywords=['python', 'agora', 'token-builder'],
27 |     classifiers=[
28 |         "Development Status :: 1 - Planning",
29 |         "Intended Audience :: Developers",
30 |         "Programming Language :: Python :: 3",
31 |     ]
32 | )
33 | 


--------------------------------------------------------------------------------