Integration channel (integration_point)

Description

The integration channel mainly defines the processing point for HTTP(S) webhooks arriving from external systems, as well as a point for WebSocket connections with predefined rights.
In some cases the integration channel defines the external system URL for sending HTTP requests to it from scripts.

Supports streaming asynchronous processing of messages arriving from WebSocket connections and sending responses and events back to them.

Supports creating project APIs using service scripts.

A WebSocket connection to the integration channel is made with token_local specified directly in the URL or in the Authorization header. More.

An HTTP(S) connection to the integration channel is made with token_local. Used for accessing project APIs, as well as for downloading call recordings and messenger webhooks.

Can be permanent or temporary. For temporary ones, set the date and time until which the integration channel is active. When the activity date is exceeded, the system automatically moves the integration channel to the expired state.

Secret fields in responses for channels of type `mcp`: password, key, and token values of domain center objects are returned as `+*****+` — in REST API collections (list, element, `mask`/`flat` field selection, create and update responses, `dry_run` check) and in the change log. An empty value is returned as is.
Secret fields: user password; SIP account `pwd` and `credentials.*.pwd`; provider `pwd` and private key bodies in `certificate_pem`; domain `dbpwd`; passwords and keys in storage `params`; integration channel `token_local`, `token_remote`, `token_remote2`; domain setting secrets (`yandex_cloud`, `sber_salute`, `azure_cloud`, `record_asr_options`, password in `project_postgresql_connstr`, `billing_options`, `survival_options` tokens, `wakeup_device_options`, `snmp_options`, private key bodies `certificate_pem`, `meet_cert_pem`, `meet_turn_cert_pem`); passwords in configuration `content`.
Filtering and sorting by a secret field, as well as a computed property name (`["property", <expression>]`) in filter and sort, are rejected (422).
The value `+*****+` sent back to a secret field on update does not change the stored value if the fields determining the secret recipient (address, port, login, URL, account, etc.; for a connection string and PEM, the rest of the value) are not changed. Otherwise, as well as in list elements and on creation, error 422: the secret must be set again. Exception — SIP account `credentials`: the element is matched with the stored one by `login` (including a different order); a new or changed `login` with `+*****+` is error 422. Likewise (422) when changing these fields without passing the secret: the stored secret is not sent to the new recipient.
Secret properties of DMS classes (`email/Accounts`, `im/Accounts`, `oauth/Providers`, etc.) are stored encrypted and returned as ciphertext (more); non-secret fields of these classes (e.g. `options.proxyUrl` with proxy credentials) are returned as is.
Unavailable (403): `/rest/v1/master/currentconfiguration`, classes `platform/log/HistoryChanges`, `oauth/Requests`, `licserver/Licenses`, `licserver/Syncs`, `system/PwdResetRequests`, `system/Invites`, `system/SelfRegisterRequests`, `/rest/v1/uc/sipusers/<id>/device` (device manager response), integration channels `/rest/v1/service/integration_points` (read and modify), and the encryption report `/rest/v1/domain/crypto_values`.
Through the MCP server, the `mcp` channel reaches only the REST API (`/rest/…​`, with masking and restrictions above) and the `/api` commands needed by tools (only `GET`; the list is in MCP server). Other paths (`/api/crud`, other `/api/admin` and `/api/monitor` commands, `/api/token`, `/exec`, proxied applications, etc.) — 403.

Limitations

  • The collection is available in any domain.

  • Licensed by a quantitative parameter: a license is consumed for the channel type.

Fields

Entity structure
{
  "id": uuid,
  "code": str,
  "type": str,
  "activity_mode": str,
  "state": str,
  "expiry_date": date,
  "token_local": str,
  "token_state": str,
  "token_remote": str,
  "token_remote2": str,
  "url": str,
  "recv_svcscriptcode": str,
  "send_svcscriptcode": str,
  "recv_svcscriptcode_ws": str,
  "send_svcscriptcode_ws": str,
  "opts": {
    "allow_files_api": bool,
    "comment": str,
    "issync": bool,
    "recv_timeout": int,
    "roles": ["special01"],
    "userid": "37a85e8-1a01-835f-4490-e78015a20052",
    "title": str
  },
  "ext": {
    "ct": date,
    "lwt": date
  }
}
Table 1. Fields
Specification Description

Field: id
Mode: inout
Type: uuid
Default: generated

Identifier. Can be specified at creation, otherwise generated by the system.

Field: code
Mode: in
Type: str
Default: required

Code. Used to associate with other entities and script components.

Field: type
Mode: in
Type: str
Default: required

Integration channel type.
The number of integration channels of each type is limited by the license.

Field: client_cert_pem
Mode: in
Type: str
Default: empty

Client certificate required to connect to the integration channel via token_local.

An integration channel for which a client certificate is specified here blocks access for unencrypted connections (if unencrypted connections are allowed by web server settings).

TLS connections to the protected port of the ws instance are by default handled according to the tls_mode policy, which may allow or disallow connections without a client certificate.
At the same time, an integration channel for which a client certificate is specified here blocks access for TLS connections that did not present a client certificate or presented a client certificate different from the one specified in the property value.

The certificate can be specified in the following ways:

  • Macro path to a PEM file with the certificate, preferably in the SYNC section (e.g. :SYNC/common/cert/token/client.pem).

  • PEM certificate body (e.g. -----BEGIN CERTIFICATE-----\nMIIEPjCCAiagAw…​x3/KVovu7g==\n-----END CERTIFICATE-----\n).

  • A string with the serial number of the current certificate placed in the 'dm/Certificates' collection of the same domain (e.g. 629607317981783735460921414187574341276182480589).

The PEM content must contain at least the certificate itself. But it may additionally contain the private key and optionally chain certificates.
If the PEM contains a private key for the client certificate, it becomes possible to use certificate path substitution macros when specifying the command line and startup parameters of microservices.
Such a combined PEM body is a standard format and can be specified:

  • both in the file referenced by the macro path;

  • and in directly specified content;

  • and in the 'certPem' field of the corresponding object from the 'dm/Certificates' collection.

Field: activity_mode
Mode: in
Type: str
Default: permanent

Integration channel activity mode.
Possible values:

  • permanent - active until the administrator disables or deletes it.

  • temporary - active until the specified date, after which it moves to the "expired" state.

Field: state
Mode: in
Type: str
Default: enabled

Integration channel state.
Possible values:

  • enabled,* disabled,* expired.

The "expired" state is set by the system automatically when the activity time is exceeded (specified in the "Active until" field).
A request can be executed only by connecting through the integration channel token in the enabled state.

Field: expiry_date
Mode: in
Type: date
Default: null

Date and time until which the integration channel is active. When the specified date is reached, it is moved to the expired state.

Field: token_local
Mode: out
Type: str
Default: generated

Local token.
Used when HTTP webhooks and WebSocket connections arrive from external systems to platform web servers for authorization and discovery of the associated integration channel.
Generated by the system on creation; returned in plaintext once — in the creation response and reissue. When read, exported, in the change log, and in events, the encrypted value (ha_v=5;…​, Encryption and keys, if the installation key is set) or a mask with the fingerprint *#<8 hex> (the first 8 characters of the token’s SHA-256: distinguishes tokens without exposing them; ***** if the token cannot be decrypted on the server).
When modifying the channel, the values *****, the mask with the current token fingerprint, and the previous encrypted value do not change the token; a mask with another token’s fingerprint (object read before reissue) is error 422; an encrypted token of the same channel (export, survival) is accepted only with binding v2 (old-format token — only exported: on creation); otherwise, including a token from before reissue, error 422. Changing the token is possible only by reissue.
Channel search by token (LOOKUP, /integration_points/<token>) is not supported.
More about token protection, where the token is used.
Secret: when read, ciphertext or a mask with the fingerprint *****#<8 hex>; the plaintext value is returned once — on generation (Encryption and keys).

Field: token_state
Mode: out
Type: str
Default: generated

Token state:

  • v2 — token created by the system with a random part and channel binding;

  • legacy — old-format token (computable from the channel identifier and domain name) — recommended for reissue;

  • invalid — token of unknown origin: 32 hexadecimal characters matching neither the old-format formula nor the channel binding (e.g. entered manually in old versions). It works, but is recommended for reissue;

  • unavailable — token cannot be decrypted on the server (no installation key).

Field: token_remote
Mode: in
Type: str
Default: empty

External token.
Used in bound scripts to build requests to an external system.
Secret: when read, plaintext; not encrypted with the installation key (Encryption and keys).

Field: token_remote2
Mode: in
Type: str
Default: empty

Additional external token.
Can be used in bound scripts to build requests to an external system.

Field: remoteipmask
Mode: in
Type: str
Default: "0.0.0.0/0"

Mask of the request sender IP address allowed to access the API through this token.
The IP address value can be:

  • an IP address (e.g. '192.168.0.10');

  • a subnet mask (e.g. '192.168.0.0/24');

  • an IP address range (e.g. '172.25.0.50+10')

Field: recv_svcscriptcode
Mode: in
Type: str
Default: empty | required

Code of the service script run to process an incoming HTTP request using token_local.
Required for type = public.

Allows implementing project APIs.

Endpoint for accessing the script: /api/token/v1/:TOKEN_LOCAL
Depending on the opts.issync field value, the script runs synchronously or asynchronously. The opts.recv_timeout field sets the maximum script execution wait time in seconds.

The following parameters are passed to the service script (available in expressions via the startparam(N) method):

  1. JSON representation of the integration channel entity through which the request arrived.

  2. Method (GET, POST, …​).

  3. Full URL (e.g. http://172.27.1.112/api/token/v1/12341234-1234-1234-1234-123412341234?s=1).

  4. Request body content.

  5. All request headers as a string.

  6. Request sender IP address.

  7. Scheme (http, https, …​)

The service script has local string variables whose values determine the HTTP response:

  • response_code - response code (e.g. 200, 404, …​)

  • response_headers - JSON object with specific response headers. For example, {"X-Era-Test1": "bbb","content-type": "application/json"}.

  • response_content - response body. For example, {"a": 1,"b": "asdf"}.

The body format can be arbitrary and is determined by the Content-Type header.

Field: send_svcscriptcode
Mode: in
Type: str
Default: empty

Code of the service script run to send an HTTP request to the channel from chatbot scripts

Field: recv_svcscriptcode_ws
Mode: in
Type: str
Default: empty

Code of the service script run to process an incoming WebSocket message using token_local.

Allows implementing project APIs.

Within a WebSocket connection to the token, the method for accessing the script API: ["message", {"qid": …​,"data": …​, …​}].
Depending on the opts.issync field value, the script runs synchronously or asynchronously. The opts.recv_timeout field sets the maximum script execution wait time in seconds.

The following parameters are passed to the service script (available in expressions via the startparam(N) method):

  1. JSON representation of the integration channel entity through which the request arrived.

  2. Method from the WebSocket message: "message".

  3. Full WebSocket connection URL (e.g. http://172.27.1.112/ws/token/v1).

  4. Message body content from the 'data' field.

  5. WebSocket connection identifier.

  6. Request sender IP address.

  7. Scheme: websocket.

The service script has local string variables whose values determine the HTTP response:

  • response_content - response content placed in the response message in the 'data' field. For example, {"a": 1,"b": "asdf"}. The format can be arbitrary. A JSON object or list is sent as the response without additional escape formatting.

Response message format:
[
  "message_result",
  {
    "qid": ...,
    "success": true,
    "data": ...
  }
]

Field: send_svcscriptcode_ws
Mode: in
Type: str
Default: empty

Code of the service script run to send a WebSocket message to the channel from chatbot scripts

Field: url
Mode: in
Type: str
Default: empty

Data provider URL. Used when building the full URL in the "Web request" component of scripts. Relevant for domains with types that preclude specifying full addresses in the properties of the "Web request" component. However, creating arbitrary domain types is disabled in all builds.

Field: opts
Mode: in
Type: object
Compound field

Field: opts.allow_files_api
Mode: in
Type: bool
Default: false

Permission to work with files. Available only for type=public

Field: opts.allow_modify
Mode: in
Type: bool
Default: true (false for type=mcp)

Modifications allowed. When false, the channel token grants read-only access in all interfaces with token authorization:

  • REST API — GET, HEAD, OPTIONS, LOOKUP, METADATA, DOWNLOADZIP methods;

  • /api — read commands (read, metadata, list, get, download, monitoring and routing tests without state change);

  • WebSocket Token API — reading, search (rest with read, lookup, hc operations), subscription with event delivery to the same connection;

  • proxied applications (e.g. /meet) — HTTP read methods, without WebSocket.

Other requests, including check without saving (dry_run), subscription with webhooks (/api/token/v1/:TOKEN/subscribe; subscribe with url in the request or the channel has url set), channel script calls (recv_svcscriptcode, recv_svcscriptcode_ws) and control commands, are rejected with access_denied.
Changing the option, as well as deleting, disabling, and expiring the channel, also affects open WebSocket connections.
When the channel type is changed to mcp, the value is reset to false unless changed in the same request (including if the previous true is passed); enabling modifications for an mcp channel is done by a separate request.

The option does not protect if the channel user can create integration channels or reissue their tokens: such channels grant access, including with allowed modifications. Channel rights are determined by the user’s roles (opts.userid) and the channel’s roles (opts.roles) according to opts.roles_mode — assign a user with minimally necessary roles, without access to integration channels.

Field: opts.filter_capabilities
Mode: in
Type: array
Default: empty

Permission for a WebSocket connection to work with specific WebSocket Token APIs. Specific ones can be listed, or all allowed by specifying [""]. Event subscription (subscribe) is always allowed for a channel of type subscr; for channels of other types — if subscribe or is listed.

Field: opts.comment
Mode: in
Type: str
Default: empty

Arbitrary comment

Field: opts.issync
Mode: in
Type: bool
Default: false

Switch for synchronous script launch mode; true — wait for the script response

Field: opts.recv_timeout
Mode: in
Type: int
Default: 0

Maximum recv_svcscript execution time in seconds. 0 means the value determined by the web server is used (10 sec.). The maximum allowed value is 60 sec.

Field: opts.roles
Mode: in
Type: array
Default: empty

Channel roles for authorization through the IAM service (REST API, /api, model tree, WebSocket Token API, MCP). If the channel has a user (opts.userid), the token roles are its roles (with group roles) and the channel roles according to opts.roles_mode; without a user — the channel roles.
Roles that the user does not have are assigned only by a user with the admin role (in intersection mode and binding to oneself — any), see opts.userid.

Field: opts.roles_mode
Mode: in
Type: str
Default: union

Token role mode for a channel with a user:

  • union — user roles and channel roles (opts.roles) together: the channel adds rights;

  • intersection — only those user roles present in the channel roles: the channel narrows the user’s rights (empty opts.roles — no roles).

Not applied for a channel without a user (token roles — opts.roles). The mode change is checked by the same rule as roles: union mode with roles beyond one’s own is set only by a user with the admin role.

Field: opts.userid
Mode: in
Type: uuid
Default: empty

Identifier of the system user on whose behalf requests are executed. This user’s roles are also applied. Required for type=mcp.
A channel bound to another user or with roles (opts.roles) that the user does not have (in opts.roles_mode=union or without a user) is created, modified (including token reissue), and deleted only by a user with the admin role (assigned directly or through a group); others — only channels bound to themselves or without a user, with roles from their own (in intersection mode and binding to oneself — with any roles: token rights are not wider than their own), otherwise error 403. Otherwise the token of such a channel would grant another user’s rights or other people’s roles.

Field: opts.title
Mode: in
Type: str
Default: empty

Arbitrary title

Field: ext
Mode: inout
Type: object
Compound field

Allows extending the compound with arbitrary keys and values

Field: ext.http_notify_format
Mode: in
Type: str
Default: empty

Webhook format for a subscr channel: not set (or another value) — POST with JSON body; qs_get — GET, notification fields passed as query string parameters; qs_post — POST with JSON body, notification fields duplicated as query string parameters.

Field: ext.ct
Mode: out
Type: date
Default: generated

Object creation time

Field: ext.lwt
Mode: out
Type: date
Default: generated

Time of last modification of the object

Integration channel types

Table 2. Integration channel types
Value Description

"public"

General-purpose integration channel. Applied when:

  • sending HTTP requests from scripts in domains with types that limit URL selection in the "Web request" component. The final URL is calculated by concatenating the url field value of the selected integration channel, the / character, and the specified page.

  • receiving incoming HTTP requests from arbitrary senders using token_local. In this case the recv_svcscriptcode script is run. In particular when receiving messages for chat sessions.

  • creating a custom internal API in service scripts over HTTP and WebSocket. The recv_svcscriptcode, recv_svcscriptcode_ws, url fields and the token_local field are used, as well as the "Send WebSocket message" component.

  • sending messages from chatbot scripts to the channel. The send_svcscriptcode and send_svcscriptcode_ws fields are used.

"subscr"

Integration channel for system event subscribers.
Supports subscription over HTTP and WebSocket.
In the first case, events are sent by webhooks to the address specified in the subscription request or to the url address.
In the second case, events are sent back to the WebSocket connection.

In each integration channel, regardless of the number of connections and subscriptions, each event is sent no more than once.

The recv_svcscriptcode, recv_svcscriptcode_ws, send_svcscriptcode, and send_svcscriptcode_ws fields are not used.

"im"

Integration channel for messenger webhooks. Incoming messages to the web server page '/api/im/v1/:TOKEN' are forwarded to the IM account service. The channel is created by the system for an account with webhooks (identifier — account identifier, code IM:<id>); an account channel (code IM:<id>) of another type or with invalid fields is converted by the system to im (token preserved), and a deleted one is recreated. A channel with the account identifier but another code, as well as service channels, are not used or modified by the system (logged as an error).

The channel token is accepted only by the webhook page; requests with it to the REST API, /api, WebSocket Token API, /exec, download, subscriptions, and the MCP server are rejected as with an unknown token. Rights (IAM) are not applied.

The fields url, recv_svcscriptcode, recv_svcscriptcode_ws, send_svcscriptcode, send_svcscriptcode_ws, opts.userid, opts.roles, opts.filter_capabilities, opts.allow_files_api, as well as opts.roles_mode = intersection and opts.allow_modify = false are not allowed (422). The channel type im is not changed; another type is changed to im only by the system (422).

The webhook address with the token is written by the system to the account (webhookInfo.url) and updated when the token is reissued. The token in the address only allows sending webhooks to this account. To protect against forged requests, set provider secrets: client_secret (vk), secret (max); for whatsapp, restrict sender addresses with the remoteipmask field.

"mcp"

Integration channel for MCP (Model Context Protocol) agents. The channel token is accepted only by the platform MCP server; direct requests with it to the REST API, /api, and WebSocket Token API are rejected as with an unknown token.

The user (opts.userid) is required: rights are determined by their roles (or channel roles opts.roles), and class access restrictions (x_security) are applied. By default access is read-only (opts.allow_modify = false). It is recommended to restrict client addresses with the remoteipmask field.

Only the REST API (with secret masking) and the /api commands used by MCP tools are available; integration channels are unavailable.

The fields url, token_remote, token_remote2, recv_svcscriptcode, recv_svcscriptcode_ws, send_svcscriptcode, and send_svcscriptcode_ws are not allowed.

other

Determined based on the domain type. The composition of other integration channel types and service processing scripts are contained in assets by domain type.

The operation is similar to the "public" channel, but the values of the url, recv_svcscriptcode, recv_svcscriptcode_ws, send_svcscriptcode, and send_svcscriptcode_ws fields are not used. Instead, values specified in domain type metadata are applied.

See also

Logical roles

  • ws services WebSocket connections and receives HTTP webhooks.

  • svc processes service scripts, including sending HTTP requests by the "Web request" component.

  • mware monitors the state of temporary integration channels and moves them to the expired state.

Integration channel token protection

The channel token (token_local) grants API access on behalf of the channel, so the platform treats it as a password. Token usage locations and protection methods are described in Integration channel tokens; secret field marking is described in Encryption and keys.

How it is issued
  • The system generates the token: 12 random bytes and a checksum bound to the domain and channel (32 hexadecimal characters). A neighboring channel’s token cannot be copied into another channel: the binding is checked on creation, modification, synchronization, and import. An encrypted token is accepted only with binding v2; a token of the old format — only as exported: when creating a channel (import of an export from a version before 1.13).

  • The plaintext token is shown once — in the create and reissue response (in the administrator, the "Token shown once" window). Save it immediately; later it can only be reissued.

How it is stored
  • In the database and domain center memory, the token is stored encrypted with the installation key (v5 format; without the key, v4 with the built-in key, see Encryption and keys). Tokens use a separate installation key subkey: ciphertexts of other secrets (settings, storages) are not accepted as a token, and an encrypted token is not decrypted by general secret decryption tools. The key is stored in the protected :SYNC/secure directory, inaccessible via API and scripts.

  • Token lookup on requests is performed by its hash (SHA-256): there are no plaintext tokens in indexes or web server caches, and decryption is not performed when validating a request.

  • When read, exported, in the change log, and in events, the encrypted value is returned (useless and not accepted as a token without the installation key) or a mask with the fingerprint *#<8 hex> — the first 8 characters of the token’s SHA-256 (it shows whether the token changed, but the token cannot be recovered). The plaintext token is not written to logs: microservice command lines are printed with a mask.

  • For product layer microservices, the token is passed by the %TOKENFILE% macro — a file with a random name in the working directory with permissions 0600; the microservice should read the file and delete it immediately; the system deletes it 10 seconds after startup (or by the %TOKEN% macro in the command line; the plaintext token written into the microservice command is replaced by the domain center with %TOKEN%). When the token is reissued, microservices are restarted with the new one.

  • The messenger webhook address (IM account webhookInfo.url) is stored with the plaintext token of the account channel of type im and updated by the system when the token is reissued: the im token is accepted only by the IM webhook (/api/im/v1/<token>) and only allows sending webhooks to this account. To protect against forged webhooks, set provider secrets (see type im).

  • Filtering and sorting by token fields (token_local, token_hash, token_state) are prohibited for everyone (422); channel search by token is internal only, by hash.

Reissue
  • POST /rest/v1/service/integration_points/<id>/token or the "Reissue token" button in the administrator — user session only. A channel of another user or with roles the caller does not have is reissued (and modified and deleted) only by a user with the admin role, see opts.userid.

  • In bulk — POST /rest/v1/service/integration_points/token (up to 20 channels; all — except service channels with permanent identifiers) or the "Reissue tokens" action for selected rows in the administrator — only an administrator (admin role) via a session; new tokens are shown once as a list.

  • The previous token stops working immediately (on other sites, after synchronization, up to 30 seconds), WebSocket connections using it are closed, and the channel’s HTTP subscriptions (/api/token/v1/<token>/subscribe, webhooks) are deleted — they must be recreated. Subscriptions are also deleted when the channel is disabled (state) or deleted. External systems and settings using the token must be reconfigured.

  • The previous token cannot be restored: the channel stores hashes of the last 16 previous tokens (token_revoked); saving an object read before reissue or modifying with the previous token is error 422.

Previous tokens (token_revoked)
  • The channel stores SHA-256 hashes of the last 16 previous tokens. A hash is added on every token change: reissue, channel modification with an encrypted token (import, survival), loading a change from a site to the center.

  • The purpose is protection against restoring a previous token: an object read before reissue (form, export file, script) would return the old token when saved. Modification with a previous token (its fingerprint mask or its encrypted value) is error 422.

  • In normal reading (object, collection) the field is not returned; it is returned in export (export=1), so it is transferred by export and survival to another system. On input (create, modify, import, load from a site), the list from the request is only added to the current one (union, SHA-256 hashes — 64 hexadecimal characters, no duplicates); entries cannot be deleted via the API — otherwise the protection could be removed by the same request that restores the old token. 16 entries are stored: the channel’s own entries are preserved, request entries occupy free slots (the request cannot displace its own entries); on token change, the previous one is added at the beginning and the oldest are displaced. Imported token validation is performed against the combined list.

  • It is transferred to sites by synchronization with the center; the list is not included in the synchronization checksum, so a discrepancy between site and center lists (for example, after communication loss) is aligned on the next token change — previous token validation is performed against the list of the node accepting the change. The list also does not participate in survival comparison (export checksums) and is transferred with the channel change, see survival.

Token state (token_state)
  • Calculated by the domain center and returned read-only: v2 — token created by the system with a random part and channel binding; legacy — old-format token, computable from the channel identifier and domain name; invalid — token of unknown origin (32 hexadecimal characters not by the formula, e.g. entered manually in old versions); unavailable — token cannot be decrypted on the server (no installation key). legacy and invalid tokens work but are recommended for reissue.

  • Visible in the administrator (channel column and card, with a warning for legacy and invalid), in the object REST API (GET /rest/v1/service/integration_points/<id>) and collection (GET /rest/v1/service/integration_points). Filtering and sorting by it are prohibited. More — the token_state field.

Old-format tokens
  • Tokens created before version 1.13 are computable from the channel identifier and domain name. On update they are encrypted and continue to work, marked as legacy in the token_state field. Reissue them.

  • Tokens entered manually in old versions (32 hexadecimal characters not by the formula) continue to work and are marked as invalid. Reissue them.

  • Tokens of service channels with permanent identifiers (product layer product_layer, service_era_meet) are reissued automatically on update. Otherwise these channels are modified on a general basis (including accepting the encrypted token of this channel).

Update
  • Before updating, make a database backup: after the transition, tokens are stored encrypted, and rollback to the previous version without a backup is impossible.

  • Set the installation key (erainstaller.sh keygen, then activate the configuration with general.crypto_kid): without it, tokens are encrypted with the built-in key, and export returns a mask.

What is not protected
  • Leakage of both the database and the installation key exposes tokens.

  • Change log and HistoryChanges records made before version 1.13 may contain plaintext tokens.

  • The VCS server service channel token (service_era_meet) is passed to the VCS server in the process command line and written to the role log at startup.

  • A token in a request URL (/api/token/v1/<token>, /ws/token/v1/<token>, /api/im/v1/<token>, /api/download/v1/<token>) may end up in proxy and external system logs — use the Authorization: Bearer header where possible.

  • Channel rights are determined by its user’s roles: a user with permission to read integration channels sees their settings. Assign users with minimally necessary roles to channels.