add rest api checksum generation

server/token_server/cpp/src/rest_api_auth.h

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <sstream>
+#include <openssl/sha.h>
+
+
+std::string sha1(const std::string &input)
+{
+    unsigned char hash[SHA_DIGEST_LENGTH];
+    SHA1(reinterpret_cast<const unsigned char *>(input.c_str()), input.length(), hash);
+    std::ostringstream oss;
+    oss << std::hex << std::setfill('0');
+    for (auto c : hash)
+    {
+        oss << std::setw(2) << static_cast<int>(c);
+    }
+    return oss.str();
+}
+
+std::string getChecksum(const std::string appSecret, std::string nonce, long curtime)
+{
+    return sha1(appSecret + nonce + std::to_string(curtime));
+}

server/token_server/cpp/test/rest_api_auth.cpp

@@ -0,0 +1,24 @@
+#include "../src/rest_api_auth.h"
+#include <gtest/gtest.h>
+#include <string>
+#include <stdint.h>
+
+class RestApiAuth_test : public testing::Test
+{
+protected:
+  virtual void SetUp() override {}
+
+  virtual void TearDown() {}
+
+  void TestGetChecksum()
+  {
+    std::string token = getChecksum("c00000000000", "1234567890", 1697168455);
+    std::cout << "checksum: " << token << std::endl;
+    EXPECT_EQ(token, "192bdbdad337836e6213aec1d93186aae9771c39");
+  }
+};
+
+TEST_F(RestApiAuth_test, RestApiAuth_test)
+{
+  TestGetChecksum();
+}

server/token_server/dotnet/TokenBuilder.Test/RestApiAuthTests.cs

@@ -0,0 +1,20 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TokenBuilder;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TokenBuilder.Tests
+{
+    [TestClass()]
+    public class RestApiAuthTests
+    {
+        [TestMethod()]
+        public void GetChecksumTest()
+        {
+            Assert.AreEqual("192bdbdad337836e6213aec1d93186aae9771c39", RestApiAuth.GetChecksum("c00000000000", "1234567890", 1697168455));
+        }
+    }
+}

server/token_server/dotnet/TokenBuilder/RestApiAuth.cs

@@ -0,0 +1,27 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace TokenBuilder
+{
+    public class RestApiAuth
+    {
+        public static string GetChecksum(string appSecret, string nonce, long curtime)
+        {
+            return ComputeSHA1($"{appSecret}{nonce}{curtime}");
+        }
+        private static string ComputeSHA1(string input)
+        {
+            using var sha1 = SHA1.Create();
+            var hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(input));
+            var sb = new StringBuilder(hash.Length * 2);
+
+            foreach (byte b in hash)
+            {
+                sb.Append(b.ToString("x2"));
+            }
+
+            return sb.ToString();
+        }
+    }
+}
+

server/token_server/go/token/restful_api_auth.go

@@ -0,0 +1,11 @@
+package token
+
+import (
+	"crypto/sha1"
+	"fmt"
+)
+
+func GetChecksum(appSecret, nonce string, curtime int64) string {
+	raw := fmt.Sprintf("%s%s%d", appSecret, nonce, curtime)
+	return fmt.Sprintf("%x", sha1.Sum([]byte(raw)))
+}

server/token_server/go/token/restful_api_auth_test.go

@@ -0,0 +1,12 @@
+package token
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSecureChecksum(t *testing.T) {
+	assert.Equal(t, "192bdbdad337836e6213aec1d93186aae9771c39",
+		GetChecksum("c00000000000", "1234567890", 1697168455))
+}

server/token_server/java/src/main/java/com/netease/im/rtctoken/RestApiAuth.java

@@ -0,0 +1,24 @@
+package com.netease.im.rtctoken;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+
+public class RestApiAuth {
+    public static String getChecksum(String appSecret, String nonce, long curTime) {
+        return sha1(appSecret + nonce + curTime);
+    }
+    private static String sha1(String input) {
+        try {
+            MessageDigest mDigest = MessageDigest.getInstance("SHA-1");
+            byte[] result = mDigest.digest(input.getBytes(StandardCharsets.UTF_8));
+            StringBuilder sb = new StringBuilder();
+            for (byte b : result) {
+                sb.append(String.format("%02x", b));
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+}

server/token_server/java/src/test/java/com/netease/im/rtctoken/RestApiAuthTest.java

@@ -0,0 +1,12 @@
+package com.netease.im.rtctoken;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class RestApiAuthTest {
+    @Test
+    public void testChecksum() throws Exception {
+       assertEquals("192bdbdad337836e6213aec1d93186aae9771c39", RestApiAuth.getChecksum("c00000000000", "1234567890", 1697168455));
+    }
+}

server/token_server/nodejs/src/RestApiAuth.js

@@ -0,0 +1,15 @@
+const crypto = require('crypto');
+
+var GetChecksum = function (appSecret, nonce, curTime) {
+    return sha1(`${appSecret}${nonce}${curTime}`);
+}
+
+const sha1 = function (input) {
+    const sha1 = crypto.createHash('sha1');
+    sha1.update(input, 'utf8');
+    return sha1.digest('hex');
+}
+
+module.exports = {
+    GetChecksum: GetChecksum,
+}

server/token_server/nodejs/test/RestAPIAuthTest.js

@@ -0,0 +1,12 @@
+const test = require('node:test');
+const assert = require('node:assert');
+
+
+const { GetChecksum } = require('../src/RestApiAuth.js');
+
+test('GetChecksum', (t) => {
+    var appSecret = "c00000000000";
+    var nonce = "1234567890";
+    var curTime = 1697168455;
+    assert.equal("192bdbdad337836e6213aec1d93186aae9771c39", GetChecksum(appSecret, nonce, curTime));
+});

server/token_server/php/src/RestApiAuth.php

@@ -0,0 +1,5 @@
+<?php
+function getChecksum(string $appSecret, string $nonce, int $curtime):string {
+    return sha1($appSecret . $nonce . $curtime);
+}
+?>

server/token_server/php/test/RestApiAuthTest.php

@@ -0,0 +1,33 @@
+<?php
+
+require_once "../src/RestApiAuth.php";
+
+class ChecksumTest
+{
+    public $appSecret = "c00000000000";
+
+    public function run()
+    {
+        $this->testChecksum();
+    }
+
+    public function testChecksum()
+    {
+        $this->assertEqual(
+            "192bdbdad337836e6213aec1d93186aae9771c39",
+            getChecksum($this->appSecret, "1234567890", 1697168455)
+        );
+    }
+
+    public static function assertEqual($expected, $actual)
+    {
+        if ($expected != $actual) {
+            echo "Assert failed" . "\n    Expected :" . $expected . "\n    Actual   :" . $actual;
+        } else {
+            echo "Assert ok\n";
+        }
+    }
+}
+
+$checksumTest = new ChecksumTest();
+$checksumTest->run();

server/token_server/python3/src/rest_api_auth.py

@@ -0,0 +1,5 @@
+import hashlib
+
+
+def get_checksum(app_secret: str, nonce: str, timestamp: int):
+    return hashlib.sha1(f'{app_secret}{nonce}{timestamp}'.encode()).hexdigest()

server/token_server/python3/test/test_get_checksum.py

@@ -0,0 +1,13 @@
+import unittest
+from unittest.mock import patch
+import sys
+import os
+import hashlib
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from src import rest_api_auth
+
+class TestGetChecksum(unittest.TestCase):
+    def test_get_checksum(self):
+        token = rest_api_auth.get_checksum("c00000000000", "1234567890", 1697168455)
+        expected = "192bdbdad337836e6213aec1d93186aae9771c39"
+        self.assertEqual(token, expected)