From f1ed1a9b17fa9844b222f5bba996265f24d95a04 Mon Sep 17 00:00:00 2001 From: MHSanaei Date: Sun, 11 Oct 2026 21:20:07 +0200 Subject: [PATCH] fix(inbounds): refuse 2022-blake3-chacha20-poly1305 on shadowsocks inbounds xray-core builds a Shadowsocks-2022 inbound with users only for the AES methods: the multi-user identity header is AES-only, so the config builder and the multi-user server both reject chacha20. Every panel inbound carries clients, so picking 2022-blake3-chacha20-poly1305 in the inbound form kept the whole core from starting; its links also failed on the client with "multi-key is not supported". The inbound form no longer offers the method and AddInbound/UpdateInbound reject it. Startup moves stored inbounds to 2022-blake3-aes-256-gcm, which takes the same 32-byte keys, so every stored key stays valid. Outbounds keep the method, since a single-key outbound to such a server works. The share-link generator drops the single-user branch that only this method reached. --- docs/content/docs/en/config/transports.mdx | 5 +- docs/content/docs/fa/config/transports.mdx | 5 +- docs/content/docs/ru/config/transports.mdx | 7 +-- docs/content/docs/zh/config/transports.mdx | 4 +- frontend/src/lib/xray/inbound-link.ts | 24 +++------ .../inbounds/form/protocols/shadowsocks.tsx | 4 +- .../schemas/protocols/inbound/shadowsocks.ts | 4 +- .../schemas/protocols/shared/shadowsocks.ts | 4 ++ frontend/src/test/inbound-from-db.test.ts | 10 ---- .../test/shadowsocks-inbound-method.test.ts | 29 +++++++++++ internal/database/db.go | 33 ++++++++++++ .../shadowsocks_server_key_migration_test.go | 52 +++++++++++++++++++ internal/web/service/client_crud.go | 9 ++-- internal/web/service/inbound.go | 4 +- .../service/shadowsocks_server_key_test.go | 47 +++++++++++++++++ internal/xray/shadowsocks2022.go | 7 +++ 16 files changed, 203 insertions(+), 45 deletions(-) create mode 100644 frontend/src/test/shadowsocks-inbound-method.test.ts diff --git a/docs/content/docs/en/config/transports.mdx b/docs/content/docs/en/config/transports.mdx index fdcd21293..a093d126e 100644 --- a/docs/content/docs/en/config/transports.mdx +++ b/docs/content/docs/en/config/transports.mdx @@ -219,8 +219,9 @@ keys from the panel's VLESS settings. ## Shadowsocks ciphers Shadowsocks inbounds support both classic ciphers and **Shadowsocks-2022** -(method names starting with `2022-blake3-`). Most ciphers are multi-user; -`2022-blake3-chacha20-poly1305` is single-user. +(method names starting with `2022-blake3-`). `2022-blake3-chacha20-poly1305` is not +offered for inbounds: Xray-core supports it only without users, and every panel +inbound has clients. Outbounds can still use it. Transports and security must match on both ends. The client's share link diff --git a/docs/content/docs/fa/config/transports.mdx b/docs/content/docs/fa/config/transports.mdx index 79cac589d..3baa706e7 100644 --- a/docs/content/docs/fa/config/transports.mdx +++ b/docs/content/docs/fa/config/transports.mdx @@ -221,8 +221,9 @@ TCP، پنل می‌تواند پس از آنکه یک کلاینت از جری ## رمزهای Shadowsocks ‏inbound‌های Shadowsocks هم از رمزهای کلاسیک و هم از **Shadowsocks-2022** -پشتیبانی می‌کنند (نام روش‌هایی که با `2022-blake3-` آغاز می‌شوند). بیشتر رمزها چندکاربره هستند؛ -‏`2022-blake3-chacha20-poly1305` تک‌کاربره است. +پشتیبانی می‌کنند (نام روش‌هایی که با `2022-blake3-` آغاز می‌شوند). روش +‏`2022-blake3-chacha20-poly1305` برای inbound ارائه نمی‌شود: Xray-core آن را فقط بدون کاربر پشتیبانی می‌کند +و هر inbound پنل کلاینت دارد. outboundها همچنان می‌توانند از آن استفاده کنند. انتقال‌ها و امنیت باید در هر دو سر یکسان باشند. لینک اشتراک کلاینت آن‌ها را diff --git a/docs/content/docs/ru/config/transports.mdx b/docs/content/docs/ru/config/transports.mdx index 7b517138b..b48899bb7 100644 --- a/docs/content/docs/ru/config/transports.mdx +++ b/docs/content/docs/ru/config/transports.mdx @@ -223,9 +223,10 @@ Vision поверх XHTTP. Сгенерируйте ключи в настрой ## Шифры Shadowsocks Inbound-соединения Shadowsocks поддерживают как классические шифры, так и -**Shadowsocks-2022** (имена методов, начинающиеся с `2022-blake3-`). Большинство -шифров рассчитаны на нескольких пользователей; `2022-blake3-chacha20-poly1305` -рассчитан на одного пользователя. +**Shadowsocks-2022** (имена методов, начинающиеся с `2022-blake3-`). Метод +`2022-blake3-chacha20-poly1305` для inbound не предлагается: Xray-core +поддерживает его только без пользователей, а у каждого inbound панели есть +клиенты. В outbound его по-прежнему можно использовать. Транспорты и безопасность должны совпадать на обоих концах. Ссылка на diff --git a/docs/content/docs/zh/config/transports.mdx b/docs/content/docs/zh/config/transports.mdx index 953ffe559..cd284ea3a 100644 --- a/docs/content/docs/zh/config/transports.mdx +++ b/docs/content/docs/zh/config/transports.mdx @@ -199,8 +199,8 @@ VLESS 支持后量子**加密**（ML-KEM / `mlkem768x25519`），它存储在入 ## Shadowsocks 加密方式 Shadowsocks 入站同时支持经典加密方式和 **Shadowsocks-2022**（以 `2022-blake3-` -开头的方法名）。大多数加密方式支持多用户；`2022-blake3-chacha20-poly1305` -为单用户。 +开头的方法名）。入站不提供 +`2022-blake3-chacha20-poly1305`：Xray-core 仅在无用户时支持它，而面板的每个入站都有客户端。出站仍可使用。 传输方式和安全层必须在两端一致。客户端的分享链接会对它们进行编码（`type=ws`、 diff --git a/frontend/src/lib/xray/inbound-link.ts b/frontend/src/lib/xray/inbound-link.ts index 25a6365c2..28006ad5a 100644 --- a/frontend/src/lib/xray/inbound-link.ts +++ b/frontend/src/lib/xray/inbound-link.ts @@ -676,13 +676,8 @@ export interface GenShadowsocksLinkInput { externalProxy?: ExternalProxyEntry | null; } -// Shadowsocks 2022 share link. The userinfo portion is base64(method:pw) -// for single-user and base64(method:settingsPw:clientPw) for multi-user -// 2022-blake3. Legacy SS (non-2022) leaves the password out of the -// userinfo entirely — matches the legacy class's password-array logic. -// Note: legacy `isSSMultiUser` returns true for everything except -// 2022-blake3-chacha20-poly1305 (a curious classification, but we -// preserve it for byte-stable parity). +// Shadowsocks share link: base64(method:clientPw) for legacy SS, and +// percent-encoded method:serverPw:clientPw for 2022-blake3 (SIP022). export function genShadowsocksLink(input: GenShadowsocksLinkInput): string { const { inbound, @@ -725,10 +720,9 @@ export function genShadowsocksLink(input: GenShadowsocksLinkInput): string { } const isSS2022 = settings.method.substring(0, 4) === '2022'; - const isSSMultiUser = settings.method !== '2022-blake3-chacha20-poly1305'; const passwords: string[] = []; if (isSS2022) passwords.push(settings.password); - if (isSSMultiUser) passwords.push(clientPassword); + passwords.push(clientPassword); if (isSS2022) { // SIP022 (2022-blake3-*) forbids base64 userinfo: method and each key are @@ -1430,10 +1424,8 @@ export function getInboundClients(inbound: Inbound): ClientShape[] | null { return (inbound.settings.clients ?? []) as ClientShape[]; case 'tuic': return (inbound.settings.clients ?? []) as ClientShape[]; - case 'shadowsocks': { - const isMultiUser = inbound.settings.method !== '2022-blake3-chacha20-poly1305'; - return isMultiUser ? ((inbound.settings.clients ?? []) as ClientShape[]) : null; - } + case 'shadowsocks': + return (inbound.settings.clients ?? []) as ClientShape[]; default: return null; } @@ -1493,18 +1485,16 @@ export function genLink(input: GenLinkInput): string { flow: client.flow, externalProxy, }); - case 'shadowsocks': { - const isMultiUser = inbound.settings.method !== '2022-blake3-chacha20-poly1305'; + case 'shadowsocks': return genShadowsocksLink({ inbound, address, port, forceTls, remark, - clientPassword: isMultiUser ? (client.password ?? '') : '', + clientPassword: client.password ?? '', externalProxy, }); - } case 'trojan': return genTrojanLink({ inbound, diff --git a/frontend/src/pages/inbounds/form/protocols/shadowsocks.tsx b/frontend/src/pages/inbounds/form/protocols/shadowsocks.tsx index ab5bc2fb7..2c82b122c 100644 --- a/frontend/src/pages/inbounds/form/protocols/shadowsocks.tsx +++ b/frontend/src/pages/inbounds/form/protocols/shadowsocks.tsx @@ -5,7 +5,7 @@ import { useFormContext } from 'react-hook-form'; import { RandomUtil } from '@/utils'; import { FormField } from '@/components/form/rhf'; -import { SSMethodSchema } from '@/schemas/protocols/shared/shadowsocks'; +import { SSInboundMethodSchema } from '@/schemas/protocols/shared/shadowsocks'; interface ShadowsocksFieldsProps { isSSWith2022: boolean; @@ -23,7 +23,7 @@ export default function ShadowsocksFields({ isSSWith2022 }: ShadowsocksFieldsPro setValue('settings.password', RandomUtil.randomShadowsocksPassword(v as string)); }} > - ({ value: m, label: m }))} /> {isSSWith2022 && ( diff --git a/frontend/src/schemas/protocols/inbound/shadowsocks.ts b/frontend/src/schemas/protocols/inbound/shadowsocks.ts index 102050924..3502cf48d 100644 --- a/frontend/src/schemas/protocols/inbound/shadowsocks.ts +++ b/frontend/src/schemas/protocols/inbound/shadowsocks.ts @@ -1,6 +1,6 @@ import { z } from 'zod'; -import { SSMethodSchema } from '../shared/shadowsocks'; +import { SSInboundMethodSchema } from '../shared/shadowsocks'; export const SSNetworkSchema = z.enum(['tcp', 'udp', 'tcp,udp']); export type SSNetwork = z.infer; @@ -30,7 +30,7 @@ export const ShadowsocksClientSchema = z.object({ export type ShadowsocksClient = z.infer; export const ShadowsocksInboundSettingsSchema = z.object({ - method: SSMethodSchema.default('2022-blake3-aes-256-gcm'), + method: SSInboundMethodSchema.default('2022-blake3-aes-256-gcm'), password: z.string().default(''), network: SSNetworkSchema.default('tcp,udp'), clients: z.array(ShadowsocksClientSchema).default([]), diff --git a/frontend/src/schemas/protocols/shared/shadowsocks.ts b/frontend/src/schemas/protocols/shared/shadowsocks.ts index 227fc1816..987b5e3b8 100644 --- a/frontend/src/schemas/protocols/shared/shadowsocks.ts +++ b/frontend/src/schemas/protocols/shared/shadowsocks.ts @@ -10,3 +10,7 @@ export const SSMethodSchema = z.enum([ '2022-blake3-chacha20-poly1305', ]); export type SSMethod = z.infer; + +// xray-core refuses a 2022 chacha20 inbound with users: the multi-user identity +// header is AES-only, and every panel inbound carries users. +export const SSInboundMethodSchema = SSMethodSchema.exclude(['2022-blake3-chacha20-poly1305']); diff --git a/frontend/src/test/inbound-from-db.test.ts b/frontend/src/test/inbound-from-db.test.ts index 759a92fe0..8f4e67f2d 100644 --- a/frontend/src/test/inbound-from-db.test.ts +++ b/frontend/src/test/inbound-from-db.test.ts @@ -266,16 +266,6 @@ describe('getInboundClients with schema-shaped inbound', () => { expect(getInboundClients(inbound)).toHaveLength(1); }); - it('returns null for SS single-user', () => { - const inbound = inboundFromDb({ - ...BASE_DB_FIELDS, - protocol: 'shadowsocks', - settings: { method: '2022-blake3-chacha20-poly1305', password: 'pw', clients: [] }, - streamSettings: { network: 'tcp', security: 'none' }, - }); - expect(getInboundClients(inbound)).toBeNull(); - }); - it('returns null for non-client protocols (http/mixed/tun/tunnel)', () => { for (const protocol of ['http', 'mixed', 'tun', 'tunnel']) { const inbound = inboundFromDb({ diff --git a/frontend/src/test/shadowsocks-inbound-method.test.ts b/frontend/src/test/shadowsocks-inbound-method.test.ts new file mode 100644 index 000000000..597dccedf --- /dev/null +++ b/frontend/src/test/shadowsocks-inbound-method.test.ts @@ -0,0 +1,29 @@ +import { describe, expect, it } from 'vitest'; + +import { ShadowsocksInboundSettingsSchema } from '@/schemas/protocols/inbound/shadowsocks'; +import { SSMethodSchema } from '@/schemas/protocols/shared/shadowsocks'; + +// xray-core refuses 2022-blake3-chacha20-poly1305 on an inbound with users (the +// multi-user identity header is AES-only), and every panel inbound carries users. +describe('shadowsocks inbound method', () => { + it('rejects 2022-blake3-chacha20-poly1305 on an inbound', () => { + const parsed = ShadowsocksInboundSettingsSchema.safeParse({ + method: '2022-blake3-chacha20-poly1305', + }); + expect(parsed.success).toBe(false); + expect(parsed.error?.issues[0].path).toEqual(['method']); + }); + + it('still accepts the AES 2022 and the legacy chacha methods', () => { + for (const method of ['2022-blake3-aes-256-gcm', 'chacha20-ietf-poly1305']) { + expect(ShadowsocksInboundSettingsSchema.parse({ method }).method).toBe(method); + } + }); + + // A single-key outbound to a 2022-chacha20 server works, so only inbounds lose it. + it('keeps 2022-blake3-chacha20-poly1305 for outbounds', () => { + expect(SSMethodSchema.parse('2022-blake3-chacha20-poly1305')).toBe( + '2022-blake3-chacha20-poly1305', + ); + }); +}); diff --git a/internal/database/db.go b/internal/database/db.go index 079f1445a..e07c0419c 100644 --- a/internal/database/db.go +++ b/internal/database/db.go @@ -181,6 +181,9 @@ func initModels() error { if err := migrateShadowsocksRemovedCiphers(); err != nil { return err } + if err := migrateShadowsocks2022ChachaInbounds(); err != nil { + return err + } if err := repairShadowsocks2022ServerKeys(); err != nil { return err } @@ -990,6 +993,36 @@ func migrateShadowsocksRemovedCiphers() error { return nil } +// migrateShadowsocks2022ChachaInbounds moves 2022-chacha20 inbounds, which the core +// refuses with users, to aes-256-gcm: same 32-byte keys, so all keys stay valid. +func migrateShadowsocks2022ChachaInbounds() error { + var inbounds []model.Inbound + if err := db.Where("protocol = ?", model.Shadowsocks).Find(&inbounds).Error; err != nil { + return err + } + for _, inbound := range inbounds { + var settings map[string]any + if json.Unmarshal([]byte(inbound.Settings), &settings) != nil { + continue + } + method, _ := settings["method"].(string) + if !xray.Shadowsocks2022NoMultiUser(method) { + continue + } + settings["method"] = "2022-blake3-aes-256-gcm" + newSettings, err := json.MarshalIndent(settings, "", " ") + if err != nil { + return err + } + if err := db.Model(&model.Inbound{}).Where("id = ?", inbound.Id). + Update("settings", string(newSettings)).Error; err != nil { + return err + } + log.Printf("Inbound %q: switched %s to 2022-blake3-aes-256-gcm; its share links changed", inbound.Tag, method) + } + return nil +} + // repairShadowsocks2022ServerKeys replaces a stored server key xray-core cannot // parse; that inbound never worked, as the core refuses to start with it. func repairShadowsocks2022ServerKeys() error { diff --git a/internal/database/shadowsocks_server_key_migration_test.go b/internal/database/shadowsocks_server_key_migration_test.go index 1a6650f1f..dc0b15ab2 100644 --- a/internal/database/shadowsocks_server_key_migration_test.go +++ b/internal/database/shadowsocks_server_key_migration_test.go @@ -67,3 +67,55 @@ func TestRepairShadowsocks2022ServerKeys(t *testing.T) { }) } } + +// A stored 2022-chacha20 inbound never let xray-core start; aes-256-gcm takes the +// same 32-byte keys, so switching keeps every stored key valid. +func TestMigrateShadowsocks2022ChachaInbounds(t *testing.T) { + dbDir := t.TempDir() + t.Setenv("XUI_DB_FOLDER", dbDir) + if err := InitDB(filepath.Join(dbDir, "x-ui.db")); err != nil { + t.Fatalf("InitDB: %v", err) + } + t.Cleanup(func() { _ = CloseDB() }) + + key := base64.StdEncoding.EncodeToString([]byte("0123456789abcdef0123456789abcdef")) + rows := map[string]struct{ settings, wantMethod string }{ + "chacha": {`{"method":"2022-blake3-chacha20-poly1305","password":"` + key + `","clients":[{"email":"c","password":"` + key + `"}]}`, "2022-blake3-aes-256-gcm"}, + "legacy chacha": {`{"method":"chacha20-ietf-poly1305","clients":[{"email":"l","password":"p"}]}`, "chacha20-ietf-poly1305"}, + } + port := 31200 + for tag, r := range rows { + port++ + ib := model.Inbound{UserId: 1, Port: port, Protocol: model.Shadowsocks, Tag: tag, Settings: r.settings} + if err := GetDB().Create(&ib).Error; err != nil { + t.Fatalf("create %s: %v", tag, err) + } + } + + if err := migrateShadowsocks2022ChachaInbounds(); err != nil { + t.Fatalf("migrateShadowsocks2022ChachaInbounds: %v", err) + } + + for tag, r := range rows { + var ib model.Inbound + if err := GetDB().Where("tag = ?", tag).First(&ib).Error; err != nil { + t.Fatal(err) + } + var got struct { + Method string `json:"method"` + Password string `json:"password"` + Clients []struct { + Password string `json:"password"` + } `json:"clients"` + } + if err := json.Unmarshal([]byte(ib.Settings), &got); err != nil { + t.Fatal(err) + } + if got.Method != r.wantMethod { + t.Errorf("%s: method %q, want %q", tag, got.Method, r.wantMethod) + } + if tag == "chacha" && (got.Password != key || got.Clients[0].Password != key) { + t.Errorf("%s: keys changed to server=%q client=%q, want both kept", tag, got.Password, got.Clients[0].Password) + } + } +} diff --git a/internal/web/service/client_crud.go b/internal/web/service/client_crud.go index c9e59ed7d..4f6a8b839 100644 --- a/internal/web/service/client_crud.go +++ b/internal/web/service/client_crud.go @@ -509,9 +509,9 @@ func shadowsocksKeyBytes(method string) int { return 0 } -// validateShadowsocks2022ServerKey refuses a server key xray-core cannot parse: -// the core then fails to build the inbound and does not start at all. -func validateShadowsocks2022ServerKey(protocol model.Protocol, settings string) error { +// validateShadowsocks2022Inbound refuses a method or server key xray-core cannot +// build an inbound from: the core then does not start at all. +func validateShadowsocks2022Inbound(protocol model.Protocol, settings string) error { if protocol != model.Shadowsocks { return nil } @@ -526,6 +526,9 @@ func validateShadowsocks2022ServerKey(protocol model.Protocol, settings string) if n == 0 { return nil } + if xray.Shadowsocks2022NoMultiUser(parsed.Method) { + return common.NewErrorf("shadowsocks inbound method %s does not support multiple users, use a 2022-blake3-aes method", parsed.Method) + } if !xray.ValidShadowsocks2022Key(parsed.Method, parsed.Password) { return common.NewErrorf("shadowsocks inbound password: %s needs a %d-byte key, base64 encoded", parsed.Method, n) } diff --git a/internal/web/service/inbound.go b/internal/web/service/inbound.go index cca391618..7c763018f 100644 --- a/internal/web/service/inbound.go +++ b/internal/web/service/inbound.go @@ -1178,7 +1178,7 @@ func (s *InboundService) AddInbound(inbound *model.Inbound) (*model.Inbound, boo if err := validateFinalMaskSalamander(inbound.StreamSettings); err != nil { return inbound, false, err } - if err := validateShadowsocks2022ServerKey(inbound.Protocol, inbound.Settings); err != nil { + if err := validateShadowsocks2022Inbound(inbound.Protocol, inbound.Settings); err != nil { return inbound, false, err } s.normalizeMtprotoSecret(inbound) @@ -1826,7 +1826,7 @@ func (s *InboundService) UpdateInbound(inbound *model.Inbound) (*model.Inbound, if err := validateFinalMaskSalamander(inbound.StreamSettings); err != nil { return inbound, false, err } - if err := validateShadowsocks2022ServerKey(inbound.Protocol, inbound.Settings); err != nil { + if err := validateShadowsocks2022Inbound(inbound.Protocol, inbound.Settings); err != nil { return inbound, false, err } s.normalizeMtprotoSecret(inbound) diff --git a/internal/web/service/shadowsocks_server_key_test.go b/internal/web/service/shadowsocks_server_key_test.go index bc0806fe5..084569505 100644 --- a/internal/web/service/shadowsocks_server_key_test.go +++ b/internal/web/service/shadowsocks_server_key_test.go @@ -75,3 +75,50 @@ func TestShadowsocks2022ServerKeyRejected(t *testing.T) { } }) } + +// xray-core builds a Shadowsocks-2022 inbound with users only for the AES methods; +// a 2022-chacha20 one with clients keeps the whole core from starting. +func TestShadowsocks2022ChachaInboundRejected(t *testing.T) { + const chacha = "2022-blake3-chacha20-poly1305" + key32 := base64.StdEncoding.EncodeToString(make([]byte, 32)) + key16 := base64.StdEncoding.EncodeToString(make([]byte, 16)) + const wantErr = "shadowsocks inbound method 2022-blake3-chacha20-poly1305 does not support multiple users" + + t.Run("add", func(t *testing.T) { + setupConflictDB(t) + nodeID, fake := setupNodeRuntime(t) + ib := &model.Inbound{ + UserId: 1, NodeID: &nodeID, Tag: "ss-chacha-add", Enable: true, Port: 41811, Protocol: model.Shadowsocks, + Settings: ss2022Settings(chacha, key32), + } + _, _, err := (&InboundService{}).AddInbound(ib) + if err == nil || !strings.Contains(err.Error(), wantErr) { + t.Fatalf("AddInbound with %s: err = %v", chacha, err) + } + if fake.addInbound.Load() != 0 { + t.Fatal("rejected inbound dispatched to the runtime") + } + }) + + t.Run("update", func(t *testing.T) { + setupConflictDB(t) + nodeID, fake := setupNodeRuntime(t) + svc := &InboundService{} + ib := &model.Inbound{ + UserId: 1, NodeID: &nodeID, Tag: "ss-chacha-update", Enable: true, Port: 41812, Protocol: model.Shadowsocks, + Settings: ss2022Settings("2022-blake3-aes-128-gcm", key16), + } + if _, _, err := svc.AddInbound(ib); err != nil { + t.Fatalf("AddInbound: %v", err) + } + update := *ib + update.Settings = ss2022Settings(chacha, key32) + _, _, err := svc.UpdateInbound(&update) + if err == nil || !strings.Contains(err.Error(), wantErr) { + t.Fatalf("UpdateInbound to %s: err = %v", chacha, err) + } + if fake.updateInbound.Load() != 0 { + t.Fatal("rejected update dispatched to the runtime") + } + }) +} diff --git a/internal/xray/shadowsocks2022.go b/internal/xray/shadowsocks2022.go index 181fb02ed..f710ae454 100644 --- a/internal/xray/shadowsocks2022.go +++ b/internal/xray/shadowsocks2022.go @@ -18,3 +18,10 @@ func ValidShadowsocks2022Key(method, key string) bool { _, err := shadowsocks_2022.ParseKey(key, Shadowsocks2022KeyBytes(method)) return err == nil } + +// Shadowsocks2022NoMultiUser reports a 2022 method xray-core refuses on an +// inbound with users: the multi-user identity header is AES-only. +func Shadowsocks2022NoMultiUser(method string) bool { + cipher, err := shadowsocks_2022.GetCipherMethod(method) + return err == nil && cipher.IsChaCha +}