License: Add new licensing mechanism

packages/devextreme/build/gulp/npm.js

@@ -112,6 +112,11 @@ const sources = (src, dist, distGlob) => (() => merge(
         .pipe(eol('\n'))
         .pipe(gulp.dest(`${dist}/bin`)),
 
+    gulp
+        .src(['license/**'])
+        .pipe(eol('\n'))
+        .pipe(gulp.dest(`${dist}/license`)),
+
     gulp
         .src('webpack.config.js')
         .pipe(gulp.dest(`${dist}/bin`)),

packages/devextreme/build/npm-bin/devextreme-license.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../license/devextreme-license');

packages/devextreme/eslint.config.mjs

@@ -34,6 +34,7 @@ export default [
             'js/viz/docs/*',
             'node_modules/*',
             'build/*',
+            'license/*',
             '**/*.j.tsx',
             'playground/*',
             'themebuilder/data/metadata/*',

packages/devextreme/js/__internal/core/license/byte_utils.ts

@@ -48,6 +48,16 @@ export function leftRotate(x: number, n: number): number {
   return ((x << n) | (x >>> (32 - n))) >>> 0;
 }
 
+export function bigIntFromBytes(bytes: Uint8Array): bigint {
+  const eight = BigInt(8);
+  const zero = BigInt(0);
+
+  return bytes.reduce(
+    (acc, cur) => (acc << eight) + BigInt(cur),
+    zero,
+  );
+}
+
 export function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
   const result = new Uint8Array(a.length + b.length);
   result.set(a, 0);

packages/devextreme/js/__internal/core/license/const.ts

@@ -0,0 +1,11 @@
+export const FORMAT = 1;
+export const RTM_MIN_PATCH_VERSION = 3;
+export const KEY_SPLITTER = '.';
+
+export const BUY_NOW_LINK = 'https://go.devexpress.com/Licensing_Installer_Watermark_DevExtremeJQuery.aspx';
+export const LICENSING_DOC_LINK = 'https://go.devexpress.com/Licensing_Documentation_DevExtremeJQuery.aspx';
+
+export const LICENSE_KEY_PLACEHOLDER = '/* ___$$$$$___devextreme___lcp___placeholder____$$$$$ */';
+
+export const NBSP = '\u00A0';
+export const SUBSCRIPTION_NAMES = `Universal, DXperience, ASP.NET${NBSP}and${NBSP}Blazor, DevExtreme${NBSP}Complete`;

packages/devextreme/js/__internal/core/license/key.ts

@@ -13,5 +13,3 @@ export const PUBLIC_KEY: PublicKey = {
     230, 44, 247, 200, 253, 170, 192, 246, 30, 12, 96, 205, 100, 249, 181, 93, 0, 231,
   ]),
 };
-
-export const INTERNAL_USAGE_ID = 'V2QpQmJVXWy6Nexkq9Xk9o';

packages/devextreme/js/__internal/core/license/lcp_key_validation/const.ts

@@ -0,0 +1,4 @@
+export const LCP_SIGNATURE = 'LCPv1';
+export const SIGN_LENGTH = 68 * 2; // 136 characters
+export const DECODE_MAP = '\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f\u0020R\u0022f6U`\'aA7Fdp,?#yeYx[KWwQMqk^T+5&r/8ItLDb2C0;H._ElZ@*N>ojOv\u005c$]m)JncBVsi<XGP=93zS%g:h(u-!14{|}~';
+export const RSA_PUBLIC_KEY_XML = '<RSAKeyValue><Modulus>94ACmndawR6kB4PEJnXBBrz5Dn8ekEf5IvL7ro5ZvOyLVDiRwZXYR2uF8tFUSYjS5v7kOg74lfpZqfPXof7kcZwV3ENuy3tB7rqPBZaAqTMp5nBsZOc2H7MgDBXzrSdd4hzASQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>';

packages/devextreme/js/__internal/core/license/lcp_key_validation/lcp_key_validation.test.ts

@@ -0,0 +1,99 @@
+/* eslint-disable */
+
+import {
+  describe,
+  expect,
+  it,
+  jest,
+} from '@jest/globals';
+import { version as currentVersion } from '@js/core/version';
+
+import { parseVersion } from '../../../utils/version';
+import { TokenKind } from '../types';
+import { parseDevExpressProductKey } from './lcp_key_validator';
+import { findLatestDevExtremeVersion, isLicenseValid } from './license_info';
+import { createProductInfo } from './product_info';
+
+const DOT_NET_TICKS_EPOCH_OFFSET = 621355968000000000n;
+const DOT_NET_TICKS_PER_MS = 10000n;
+const DEVEXTREME_HTML_JS_BIT = 1n << 54n;
+
+function msToDotNetTicks(ms: number): string {
+  return (BigInt(ms) * DOT_NET_TICKS_PER_MS + DOT_NET_TICKS_EPOCH_OFFSET).toString();
+}
+
+function createLcpSource(payload: string): string {
+  const signature = 'A'.repeat(136);
+  return `LCPv1${btoa(`${signature}${payload}`)}`;
+}
+
+function loadParserWithBypassedSignatureCheck() {
+  jest.resetModules();
+  jest.doMock('./utils', () => {
+    const actual = jest.requireActual('./utils') as Record<string, unknown>;
+    return {
+      ...actual,
+      encodeString: (text: string) => text,
+      shiftDecodeText: (text: string) => text,
+      verifyHash: () => true,
+    };
+  });
+
+  // eslint-disable-next-line
+  const { parseDevExpressProductKey } = require('./lcp_key_validator');
+  // eslint-disable-next-line
+  const { TokenKind } = require('../types');
+  return { parseDevExpressProductKey, TokenKind };
+}
+
+function getTrialLicense() {
+  const { major, minor } = parseVersion(currentVersion);
+  const products = [
+    createProductInfo(parseInt(`${major}${minor}`, 10), 0n),
+  ];
+  return { products };
+}
+
+describe('LCP key validation', () => {
+  it('serializer returns an invalid license for malformed input', () => {
+    const token = parseDevExpressProductKey('not-a-real-license');
+    expect(token.kind).toBe(TokenKind.corrupted);
+  });
+
+  (process.env.DX_PRODUCT_KEY ? it : it.skip)('developer product license fixtures parse into valid LicenseInfo instances', () => {
+    const token = parseDevExpressProductKey(process.env.DX_PRODUCT_KEY as string);
+    expect(token.kind).toBe(TokenKind.verified);
+  });
+
+  it('trial fallback does not grant product access', () => {
+    const trialLicense = getTrialLicense();
+    expect(isLicenseValid(trialLicense)).toBe(true);
+
+    const version = findLatestDevExtremeVersion(trialLicense);
+
+    expect(version).toBe(undefined);
+  });
+
+  it('does not classify a valid DevExtreme product key as trial-expired when expiration metadata is in the past', () => {
+    const { parseDevExpressProductKey, TokenKind } = loadParserWithBypassedSignatureCheck();
+    const expiredAt = msToDotNetTicks(Date.UTC(2020, 0, 1));
+
+    const payload = `meta;251,${DEVEXTREME_HTML_JS_BIT},0,${expiredAt};`;
+    const token = parseDevExpressProductKey(createLcpSource(payload));
+
+    expect(token.kind).toBe(TokenKind.verified);
+  });
+
+  it('returns trial-expired for expired trial keys without DevExtreme product access', () => {
+    const { parseDevExpressProductKey, TokenKind } = loadParserWithBypassedSignatureCheck();
+    const expiredAt = msToDotNetTicks(Date.UTC(2020, 0, 1));
+
+    const payload = `meta;251,0,0,${expiredAt};`;
+    const token = parseDevExpressProductKey(createLcpSource(payload));
+
+    expect(token.kind).toBe(TokenKind.corrupted);
+    if (token.kind === TokenKind.corrupted) {
+      expect(token.error).toBe('trial-expired');
+    }
+  });
+});

packages/devextreme/js/__internal/core/license/lcp_key_validation/lcp_key_validator.ts

@@ -0,0 +1,121 @@
+import { FORMAT } from '../const';
+import {
+  DESERIALIZATION_ERROR,
+  type ErrorToken,
+  GENERAL_ERROR,
+  PRODUCT_KIND_ERROR,
+  type Token,
+  TokenKind,
+  TRIAL_EXPIRED_ERROR,
+  VERIFICATION_ERROR,
+} from '../types';
+import {
+  LCP_SIGNATURE,
+  RSA_PUBLIC_KEY_XML,
+  SIGN_LENGTH,
+} from './const';
+import { findLatestDevExtremeVersion, getMaxExpiration } from './license_info';
+import { createProductInfo, type ProductInfo } from './product_info';
+import {
+  dotNetTicksToMs,
+  encodeString,
+  shiftDecodeText,
+  verifyHash,
+} from './utils';
+
+interface ParsedProducts {
+  products: ProductInfo[];
+  errorToken?: ErrorToken;
+}
+
+export function isProductOnlyLicense(license: string): boolean {
+  return typeof license === 'string' && license.startsWith(LCP_SIGNATURE);
+}
+
+function productsFromString(encodedString: string): ParsedProducts {
+  if (!encodedString) {
+    return {
+      products: [],
+      errorToken: GENERAL_ERROR,
+    };
+  }
+
+  try {
+    const splitInfo = encodedString.split(';');
+    const productTuples = splitInfo.slice(1).filter((entry) => entry.length > 0);
+    const products = productTuples.map((tuple) => {
+      const parts = tuple.split(',');
+      const version = Number.parseInt(parts[0], 10);
+      const productsValue = BigInt(parts[1]);
+      const expiration = parts.length > 3 ? dotNetTicksToMs(parts[3]) : Infinity;
+      return createProductInfo(
+        version,
+        productsValue,
+        expiration,
+      );
+    });
+
+    return {
+      products,
+    };
+  } catch (error) {
+    return {
+      products: [],
+      errorToken: DESERIALIZATION_ERROR,
+    };
+  }
+}
+
+export function parseDevExpressProductKey(productsLicenseSource: string): Token {
+  if (!isProductOnlyLicense(productsLicenseSource)) {
+    return GENERAL_ERROR;
+  }
+
+  try {
+    const productsLicense = atob(
+      shiftDecodeText(productsLicenseSource.substring(LCP_SIGNATURE.length)),
+    );
+
+    const signature = productsLicense.substring(0, SIGN_LENGTH);
+    const productsPayload = productsLicense.substring(SIGN_LENGTH);
+
+    if (!verifyHash(RSA_PUBLIC_KEY_XML, productsPayload, signature)) {
+      return VERIFICATION_ERROR;
+    }
+
+    const {
+      products,
+      errorToken,
+    } = productsFromString(
+      encodeString(productsPayload, shiftDecodeText),
+    );
+
+    if (errorToken) {
+      return errorToken;
+    }
+
+    const maxVersionAllowed = findLatestDevExtremeVersion({ products });
+
+    if (!maxVersionAllowed) {
+      const maxExpiration = getMaxExpiration({ products });
+      if (maxExpiration !== Infinity && maxExpiration < Date.now()) {
+        return TRIAL_EXPIRED_ERROR;
+      }
+    }
+
+    if (!maxVersionAllowed) {
+      return PRODUCT_KIND_ERROR;
+    }
+
+    return {
+      kind: TokenKind.verified,
+      payload: {
+        customerId: '',
+        maxVersionAllowed,
+        format: FORMAT,
+      },
+    };
+  } catch (error) {
+    return GENERAL_ERROR;
+  }
+}

packages/devextreme/js/__internal/core/license/lcp_key_validation/license_info.ts

@@ -0,0 +1,28 @@
+import { isProduct, type ProductInfo } from './product_info';
+import { ProductKind } from './types';
+
+export interface LicenseInfo {
+  readonly products: ProductInfo[];
+}
+
+export function isLicenseValid(info: LicenseInfo): boolean {
+  return Array.isArray(info.products) && info.products.length > 0;
+}
+
+export function getMaxExpiration(info: LicenseInfo): number {
+  const expirationDates = info.products
+    .map((p) => p.expiration)
+    .filter((e) => e > 0 && e !== Infinity);
+  if (expirationDates.length === 0) return Infinity;
+  return Math.max(...expirationDates);
+}
+
+export function findLatestDevExtremeVersion(info: LicenseInfo): number | undefined {
+  if (!isLicenseValid(info)) {
+    return undefined;
+  }
+
+  const sorted = [...info.products].sort((a, b) => b.version - a.version);
+
+  return sorted.find((p) => isProduct(p, ProductKind.DevExtremeHtmlJs))?.version;
+}