Regole XML
Oltre che con le opzioni specificate sulla riga di comando o tramite il task Babel di MSBuild, Babel Obfuscator può essere controllato e configurato con regole definite in file XML esterni. Queste regole XML offrono un controllo granulare sul processo di offuscamento e ti permettono di agire su assembly, tipi, metodi e altri elementi del codice specifici.
File di regole
I file di regole di Babel sono documenti XML che contengono le informazioni di configurazione usate per personalizzare e controllare il processo di offuscamento. Con questi file puoi definire con precisione quali funzionalità di offuscamento applicare a parti specifiche del tuo codice, con un controllo granulare sulla protezione dei tuoi assembly.
<Rules xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Rule name="rule 1" feature="default" exclude="false">
</Rule>
<Rule name="rule 2" feature="control flow" exclude="true">
</Rule>
</Rules>L’elemento Rules può definire un attributo targetAssembly che limita l’ambito delle regole che contiene a un assembly specifico. Se l’attributo targetAssembly non è specificato, le regole si applicano a tutti gli assembly elaborati. Esempio:
<Rules xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
targetAssembly="ACME.Data">Nel file di regole XML, le regole vengono elaborate in sequenza dall’alto verso il basso, nell’ordine in cui compaiono. Questa elaborazione sequenziale ti permette di sovrascrivere le regole esistenti con regole più specifiche elencate dopo, ottenendo una struttura di regole flessibile e gerarchica.
Elemento Rules
L’elemento Rules è il contenitore radice che definisce un insieme di regole da applicare all’assembly target. Può contenere più elementi figlio Rule, ciascuno dei quali specifica un diverso comportamento di offuscamento.
| Attributo | Descrizione |
|---|---|
| targetAssembly | Specifica il nome completo dell’assembly a cui vengono applicate le regole. Se non è definito, le regole si applicano a tutti gli assembly coinvolti nel processo di offuscamento. |
Elemento Rule
L’elemento Rule definisce una regola di offuscamento di Babel che può riguardare una o più funzionalità di Babel Obfuscator. Ogni regola specifica quali elementi del codice sono interessati e come applicare a essi le funzionalità di offuscamento.
| Attributo | Descrizione |
|---|---|
| name | Un nome descrittivo e leggibile per la regola, che aiuta a identificarne lo scopo |
| feature | Il nome della funzionalità dell’offuscatore, o un elenco separato da virgole di nomi di funzionalità, a cui la regola si riferisce. Puoi specificare più funzionalità per applicare la stessa regola a diversi aspetti dell’offuscamento |
| exclude | Valore booleano che indica se la regola impedisce l’esecuzione delle funzionalità specificate. Imposta “true” per escludere i simboli dall’offuscamento, oppure “false” per includerli esplicitamente |
| applyToMembers | Valore booleano che indica se applicare la regola a tutti i membri di un simbolo che soddisfa i criteri della regola. Quando è abilitato, la regola si propaga ai membri annidati |
| locked | Valore booleano che indica se la regola è immutabile e non può essere sovrascritta dalle regole successive nell’ordine di elaborazione |
L’attributo feature definisce la funzionalità dell’offuscatore su cui agisce la regola. Gli attributi name ed exclude sono obbligatori, mentre l’attributo feature è facoltativo. Se non è specificato, la funzionalità assume il valore “default”, che indica la funzionalità di ridenominazione.
Le funzionalità dell’offuscatore sono stringhe predefinite che corrispondono a specifiche capacità di offuscamento. Tutti i nomi di funzionalità supportati sono elencati nelle tabelle seguenti.
Tabella delle funzionalità
Le seguenti funzionalità possono riguardare tutti i tipi di simboli definiti in un assembly, compresi tipi, metodi, proprietà, campi ed eventi:
| Funzionalità | Descrizione |
|---|---|
| all | Indica tutte le funzionalità di offuscamento disponibili |
| default | La funzionalità predefinita indica l’offuscamento tramite ridenominazione dei simboli |
| agent | Indica le funzioni dell’Obfuscation Agent |
| cleanup attributes | Rimuove gli attributi indesiderati dai metadati dell’assembly |
| control flow | Applica l’offuscamento del flusso di controllo per rendere la logica del codice più difficile da capire |
| dead code | Abilita l’ottimizzazione di rimozione del codice inutilizzato |
| dynamic proxy | Sostituisce le chiamate dirette ai metodi con chiamate tramite proxy dinamico |
| embed | Incorpora gli assembly dipendenti nell’assembly target |
| merge | Unisce più assembly in un unico assembly |
| msil encryption | Cifra i corpi dei metodi con la cifratura del codice MSIL (Microsoft Intermediate Language) |
| renaming | Offusca i nomi dei membri (tipi, metodi, proprietà, campi, eventi) |
| renaming blob | Rinomina i valori letterali stringa che corrispondono a simboli rinominati, mantenendo il funzionamento del codice |
| resource encryption | Cifra le risorse incorporate nell’assembly |
| string encryption | Cifra i valori letterali stringa inline presenti nel codice |
| value encryption | Cifra i valori costanti inline e le inizializzazioni di array |
| inline | Espande inline le chiamate ai metodi per rendere meno visibile la struttura del codice |
| instrumentation | Abilita la strumentazione del codice per il monitoraggio e l’analisi |
| optimizations | Applica varie ottimizzazioni dei metadati e del codice |
| xaml | Gestisce la ridenominazione dei simboli referenziati nelle risorse XAML o BAML |
Le seguenti funzionalità di offuscamento sono specifiche dei metodi e possono essere applicate solo a simboli di tipo metodo:
| Funzionalità | Descrizione |
|---|---|
| msil encryption get stream | Dichiara il metodo usato per ottenere il flusso di origine del codice cifrato per la decifratura MSIL |
| string encryption encrypt method | Definisce il metodo personalizzato usato per cifrare i valori letterali stringa |
| string encryption decrypt method | Definisce il metodo personalizzato usato per decifrare i valori letterali stringa in fase di esecuzione |
| instrumentation on entry method | Definisce il metodo da chiamare all’ingresso in un metodo strumentato |
| instrumentation on exit method | Definisce il metodo da chiamare all’uscita da un metodo strumentato |
| instrumentation on exception method | Definisce il metodo da chiamare quando si verifica un’eccezione in un metodo strumentato |
| module initializer | Indica un metodo da eseguire automaticamente quando il runtime inizializza il modulo |
Ogni elemento Rule può contenere elementi figlio come Access, Target, Pattern, HasAttribute, Properties e Description. L’elemento Pattern è obbligatorio, mentre tutti gli altri sono facoltativi. Questi elementi figlio aggiungono alla regola ulteriori possibilità di filtro e di configurazione. Esempio:
<Rule name="DataWriter" feature="msil encryption" exclude="false">
<Target>Methods</Target>
<Pattern>SQLUtils.DataWriter::*</Pattern>
<Properties>
<Cache>true</Cache>
<MinInstructionCount>6</MinInstructionCount>
</Properties>
<Description>Encrypt all methods of the DataWriter class.</Description>
</Rule>Di seguito trovi l’elenco completo di tutti i possibili elementi figlio di Rule:
| Elemento |
|---|
| Access |
| Targets |
| Pattern |
| HasAttribute |
| HasBase |
| Implements |
| Namespace |
| Properties |
| Description |
Elemento Access
Limita l’ambito della regola ai simboli con i modificatori di visibilità specificati. I valori possibili sono All o una qualsiasi combinazione di Public, Protected, Internal, Private, FamilyAndAssembly e FamilyOrAssembly. Se questo elemento non è presente, viene usato il valore predefinito All, cioè la regola si applica ai simboli di qualsiasi visibilità.
| Accesso | Descrizione |
|---|---|
| Public | Accessibile da qualsiasi tipo in qualsiasi assembly. |
| Protected | Accessibile dall’interno dello stesso tipo del membro e da tutti i tipi derivati che ereditano da esso (noto anche come accesso Family). |
| Internal | Accessibile solo all’interno dell’assembly in cui il tipo è definito (noto anche come accesso Assembly). |
| Private | Accessibile solo dall’interno dello stesso tipo del membro o da un tipo annidato in quel tipo. |
| FamilyOrAssembly | Accessibile dai tipi che soddisfano l’accesso Family oppure l’accesso Assembly (protected internal in C#). |
| FamilyAndAssembly | Accessibile solo dai tipi che soddisfano sia l’accesso Family sia l’accesso Assembly (private protected in C#). |
Elemento Targets
Limita l’ambito della regola a tipi specifici di simboli del codice. I valori accettati sono All o una qualsiasi combinazione di Classes, Delegates, Structures, Interfaces, Enums, Events, Methods, Properties, Fields, StaticFields e Resources. Se questo elemento non è presente, si assume il valore predefinito All e la regola si applica a tutti i tipi di simboli.
Elemento Pattern
Nella definizione di una regola XML di Babel Obfuscator, l’elemento Pattern è un componente fondamentale per identificare e selezionare i simboli dell’assembly soggetti a offuscamento. Accetta un nome completo di simbolo, un’espressione con caratteri jolly o un’espressione regolare, e costituisce così un meccanismo di filtro versatile e adattabile per selezionare elementi specifici del codice.
Espressioni con caratteri jolly: per criteri di selezione più semplici, l’elemento Pattern può contenere caratteri jolly. Il carattere ’?’ rappresenta un singolo carattere qualsiasi, mentre ’*’ indica zero o più caratteri. In questo modo puoi definire criteri di selezione ampi ma controllati e selezionare facilmente gruppi di simboli correlati senza scrivere modelli complessi.
Espressioni regolari: per esigenze di filtro più complesse e precise, nell’elemento Pattern puoi usare le espressioni regolari. In questo caso l’attributo isRegEx deve essere impostato su “true”, per indicare che il modello va interpretato come espressione regolare e non come stringa letterale o modello con caratteri jolly. È consigliabile racchiudere l’espressione regolare in una sezione CDATA, per garantire la corretta analisi dell’XML e l’interpretazione esatta dei caratteri speciali. Per esempio:
<Pattern isRegEx="true"><![CDATA[^Properties.*]]></Pattern> Formato del nome completo
Nella definizione del modello di una regola XML di Babel Obfuscator, il formato del nome completo di un simbolo varia in base al tipo di simbolo a cui la regola si riferisce. Questa distinzione garantisce un offuscamento preciso ed efficace per i diversi tipi di simboli, mantenendo chiarezza e coerenza.
Tipi (classi, strutture, enumerazioni, interfacce): il formato convenzionale è NamespaceName.TypeName, una notazione semplice per le dichiarazioni di tipo di base.
Tipi annidati: per i tipi annidati (tipi definiti all’interno di altri tipi), il formato usa una barra come separatore: NamespaceName.TypeName/NestedTypeName. Questa notazione distingue chiaramente i tipi annidati dai tipi che li contengono e mantiene la relazione gerarchica.
Tipi generici: la rappresentazione dei tipi generici inizia con NamespaceName.TypeName, seguito dagli argomenti di tipo generico racchiusi tra parentesi angolari:
NamespaceName.TypeName<GenericArgumentList>
GenericArgumentList: questo elemento non è un modello indipendente, ma una parte integrante del modello dei tipi generici. Definisce l’elenco separato da virgole degli argomenti di tipo generico, ciascuno specificato con namespace e nome di tipo completi:
NamespaceName.TypeName1,NamespaceName.TypeName2,...,NamespaceName.TypeNameN
Metodi: il formato tipico dei metodi comprende il namespace, il nome del tipo, il nome del metodo, l’elenco dei parametri e, facoltativamente, il tipo restituito:
NamespaceName.TypeName::MethodName(ParameterList):ReturnType
Nota che l’indicazione di ReturnType nel modello è facoltativa e nella maggior parte dei casi può essere omessa.
Proprietà: il formato previsto per le proprietà segue questa struttura:
NamespaceName.TypeName::PropertyName:PropertyType
In genere non è necessario includere nel modello il tipo della proprietà, che può essere omesso.
Eventi: il formato degli eventi è il seguente:
NamespaceName.TypeName::EventName:EventHandlerType
Questo formato comprende sia il nome dell’evento sia il tipo del gestore associato.
Campi: i campi seguono il formato:
NamespaceName.TypeName::FieldName:FieldType
Come per le proprietà, il tipo del campo è di solito facoltativo e non è richiesto nella maggior parte delle definizioni di modello.
ParameterList: questo componente è associato esclusivamente al modello dei metodi. Elenca i nomi di tipo completi dei parametri, separati da virgole:
NamespaceName.TypeName1,NamespaceName.TypeName2,...,NamespaceName.TypeNameN
Ricorda che questi modelli servono a specificare con precisione quali parti del codice Babel Obfuscator deve offuscare. La sintassi esatta può variare leggermente in base al contesto e ai requisiti specifici della tua strategia di offuscamento. Con modelli accurati, le regole di offuscamento agiscono solo sui simboli previsti.
Elemento HasAttribute
Specifica un elenco separato da virgole di nomi completi di tipi di attributi personalizzati. Se il simbolo target è decorato con almeno uno di questi attributi, la regola viene applicata a quel simbolo. Questo elemento fornisce un filtro basato sugli attributi per indirizzare le regole con precisione.
Questo elemento supporta l’attributo facoltativo onEnclosingType. Se impostato su “true”, questo attributo specifica che l’attributo personalizzato va cercato sul tipo che contiene il simbolo target anziché sul simbolo stesso:
<HasAttribute onEnclosingType="true">System.SerializableAttribute</HasAttribute>Questa configurazione corrisponde a simboli come metodi, proprietà, campi ed eventi che appartengono a qualsiasi tipo decorato con SerializableAttribute.
Elemento HasBase
Specifica un elenco separato da virgole di nomi completi di tipi base. La regola corrisponde a un simbolo di tipo se il tipo target deriva da uno dei tipi base specificati. Questo elemento permette di filtrare l’applicazione delle regole in base all’ereditarietà.
Questo elemento supporta l’attributo facoltativo onEnclosingType. Se impostato su “true”, questo attributo specifica che Babel deve cercare nella gerarchia del tipo che contiene i simboli target, così puoi applicare le regole in base alla struttura di ereditarietà dei tipi contenitori.
Elemento Namespace
Limita la regola ai simboli di un namespace specificato. Fornisce un filtro a livello di namespace per l’applicazione delle regole.
<Namespace>ACME.Data</Namespace>La regola viene applicata a tutti i simboli definiti nel namespace ACME.Data e nei suoi namespace annidati.
Elemento Properties
L’elemento Properties definisce una raccolta di elementi figlio XML usati per personalizzare il comportamento della funzionalità selezionata dalla regola. Ogni funzionalità di offuscamento supporta proprietà specifiche che ne controllano il funzionamento e regolano con precisione il modo in cui elabora i simboli corrispondenti.
<Rule name="DataWriter" feature="msil encryption" exclude="false">
<Target>Methods</Target>
<Pattern>ACME.Data.DataWriter::*</Pattern>
<Properties>
<Cache>true</Cache>
<MinInstructionCount>6</MinInstructionCount>
</Properties>
<Description>Encrypts code in the DataWriter class.</Description>
</Rule>Questa regola configura la funzionalità msil encryption impostando le proprietà Cache e MinInstructionCount per tutti i metodi della classe DataWriter.
Di seguito trovi l’elenco completo degli elementi di proprietà supportati da ciascuna funzionalità di offuscamento:
agent
| Proprietà | Tipo | Descrizione |
|---|---|---|
| TaskNameList | Stringa | Un elenco separato da virgole dei nomi dei task dell’Agent a cui si applica la regola. |
cleanup attributes
| Proprietà | Tipo | Descrizione |
|---|---|---|
| Attributes | Stringa | Un elenco separato da virgole di nomi qualificati di tipi di attributi o di espressioni regolari che corrispondono ai membri da includere nella ricerca. |
| IncludeMembers | Stringa | Un elenco separato da virgole di nomi qualificati di simboli o di espressioni regolari che corrispondono ai membri da includere nella ricerca. |
| ExcludeMembers | Stringa | Un elenco separato da virgole di nomi qualificati di simboli o di espressioni regolari che corrispondono ai membri da escludere dalla ricerca. |
control flow
| Proprietà | Tipo | Descrizione |
|---|---|---|
| ILIterations | Intero | Specifica il numero di iterazioni da applicare durante l’offuscamento del flusso di controllo; valori più alti producono strutture di codice più complesse. |
| EmitInvalidOpcodes | Booleano | Se abilitata, aggiunge opcode non validi nel flusso del metodo per confondere disassemblatori e decompilatori. |
| ChangeIfStatement | Booleano | Se abilitata, trasforma e offusca le istruzioni condizionali if per rendere la logica più difficile da seguire. |
| AddSwitchStatement | Booleano | Se abilitata, arricchisce il flusso di controllo inserendo istruzioni switch nel flusso del metodo, creando percorsi di esecuzione più complessi. |
| ScrambleControlFlow | Booleano | Se abilitata, produce “spaghetti code” inserendo diramazioni e istruzioni di salto irrilevanti che oscurano in modo significativo il flusso di controllo originale. |
| MaxSwitchTargets | Intero | Imposta il numero massimo di destinazioni case consentite nell’offuscamento del flusso di controllo con switch, controllando la complessità delle istruzioni switch generate. |
| HideCaseConstantExpressions | Booleano | Se abilitata, nasconde i valori costanti calcolati nell’offuscamento del flusso di controllo con switch, usando espressioni calcolate al posto dei valori letterali. |
| RandomCall | Booleano | Se abilitata, aggiunge istruzioni di chiamata a metodi casuali per confondere ulteriormente l’analisi (disponibile solo quando è abilitato il flusso di controllo con switch). |
| AddMethodToken (*) | Booleano | Se abilitata, arricchisce il flusso di controllo aggiungendo istruzioni di caricamento di token nel flusso del metodo, creando ulteriore complessità. |
| StackUnderflow (*) | Booleano | Se abilitata, inserisce istruzioni che creano condizioni di underflow dello stack di valutazione, rendendo più difficile l’analisi statica. |
(*) Queste opzioni generano codice IL non verificabile. Se il tuo assembly deve essere eseguito in un ambiente parzialmente attendibile o deve superare la convalida di PEVerify, non abilitarle.
renaming
| Proprietà | Tipo | Descrizione |
|---|---|---|
| DisableOverloading | Booleano | Se abilitata, disabilita la ridenominazione con overload: i metodi con firme diverse ricevono nomi offuscati diversi anziché condividere lo stesso nome. |
| DisableUnicode | Booleano | Se abilitata, impedisce l’uso di caratteri Unicode nei nomi offuscati, limitando i nomi ai soli caratteri ASCII. |
| Internalize | Booleano | Se abilitata, cambia da public a internal la visibilità di tutti i tipi pubblici che corrispondono alla regola, riducendo la superficie API dell’assembly. |
| NameLength | Intero | Specifica la lunghezza desiderata dei nomi dei simboli rinominati, così puoi controllare quanto devono essere lunghi o corti gli identificatori offuscati. |
| NamePrefix | Stringa | Definisce una stringa di prefisso da anteporre a tutti i simboli rinominati, utile per identificare o classificare i nomi offuscati. |
string encryption
| Proprietà | Tipo | Descrizione |
|---|---|---|
| MinInstructionCount | Intero | Imposta la soglia minima del numero di istruzioni che un metodo deve avere perché la regola venga applicata. I metodi con meno istruzioni vengono esclusi. |
| MaxInstructionCount | Intero | Imposta la soglia massima del numero di istruzioni che un metodo può avere perché la regola venga applicata. I metodi con più istruzioni vengono esclusi. |
merge
| Proprietà | Tipo | Descrizione |
|---|---|---|
| CopyAttributes | Stringa | Un elenco separato da virgole di nomi completi di tipi di attributi personalizzati o di espressioni regolari, usato per filtrare gli attributi da copiare dall’assembly di origine all’assembly target durante l’unione. |
| NoCopyAttributes | Stringa | Un elenco separato da virgole di nomi completi di tipi di attributi personalizzati o di espressioni regolari, usato per filtrare gli attributi da NON copiare nell’assembly target durante l’unione. |
| Internalize | Booleano | Se abilitata, cambia da public a internal la visibilità di tutti i tipi uniti che corrispondono alla regola, nascondendoli agli assembly esterni. |
| MergeAction | Default/Discard/Redirect | Specifica l’azione di unione da eseguire per il tipo selezionato. Default esegue l’unione normale, Discard esclude il tipo dall’unione e Redirect reindirizza i riferimenti a un altro tipo dell’assembly target (specificato dalla proprietà RedirectTo). |
| RedirectTo | Stringa | Contiene il nome completo del tipo dell’assembly target che sostituisce il tipo di origine quando è stata specificata l’azione di unione Redirect. |
msil encryption
| Proprietà | Tipo | Descrizione |
|---|---|---|
| Cache | Booleano | Se abilitata, mantiene in memoria il metodo decifrato, così la compilazione JIT avviene solo al primo accesso e le prestazioni successive migliorano. |
| Internal | Booleano | Se abilitata, memorizza il codice MSIL cifrato all’interno dell’assembly target; se disabilitata, lo memorizza in un file esterno. |
| Password | Stringa | Specifica la password usata per cifrare il codice del metodo, aggiungendo un ulteriore strato di protezione. |
| Source | Stringa | Definisce un nome identificativo dell’origine del codice cifrato, utile per organizzare più origini di cifratura. |
| MinInstructionCount | Intero | Imposta la soglia minima del numero di istruzioni che un metodo deve avere perché la regola venga applicata. |
| MaxInstructionCount | Intero | Imposta la soglia massima del numero di istruzioni che un metodo può avere perché la regola venga applicata. |
optimizations
| Proprietà | Tipo | Descrizione |
|---|---|---|
| ClassSealing | Booleano | Se abilitata, applica l’ottimizzazione di sigillatura delle classi, contrassegnando come sealed (final) le classi che non hanno tipi derivati e migliorando le prestazioni. |
| ConstRemoval | Booleano | Se abilitata, rimuove i metadati dei campi costanti, sostituendo i riferimenti con i valori letterali direttamente nel codice. |
| DisgregateRemoval | Booleano | Se abilitata, rimuove i metadati di proprietà ed eventi, riducendo l’ingombro dei metadati dell’assembly. |
| EnumRemoval | Booleano | Se abilitata, rimuove le definizioni dei tipi di enumerazione, sostituendole con i rispettivi tipi integrali sottostanti. |
| UnwantedAttributes | Booleano | Se abilitata, rimuove gli attributi personalizzati indesiderati che possono esporre dettagli di implementazione o informazioni di debug. |
Elemento Description
Fornisce una descrizione testuale dello scopo e del comportamento della regola. La descrizione viene mostrata nel log di offuscamento e aiuta a capire che cosa fa ogni regola quando esamini il processo di offuscamento.
Configurare le regole
Puoi passare i file di regole a Babel Obfuscator dalla riga di comando, dal task Babel di MSBuild o da Babel Desktop. Scegli il metodo più adatto alla tua build.
Riga di comando
babel myapp.exe --rules babelRules.xmlL’opzione --rules può essere specificata più volte sulla riga di comando per includere altri file di regole XML. Così puoi organizzare le regole in file separati e combinarle secondo necessità.
Task Babel di MSBuild
<ItemGroup>
<RuleFile Include="babelRules.xml" />
</ItemGroup>
<Babel RulesFiles="@(RuleFile)" />L’opzione RulesFiles di Babel Obfuscator accetta un elenco di file di regole XML, che puoi definire con l’elemento ItemGroup nel tuo file di progetto MSBuild. In questo modo puoi specificare più file di regole e gestirli facilmente all’interno della struttura del progetto. Ogni file di regole elencato nel gruppo di elementi viene trattato come un input separato per Babel Obfuscator e può servire a specificare regole e impostazioni di offuscamento diverse per parti diverse del tuo codice.
Oltre a usare file di regole XML esterni, puoi incorporare la definizione delle regole XML direttamente nel file di progetto con l’attributo XmlRules del task Babel, come mostrato di seguito:
<PropertyGroup>
<XmlRules>
<Rules targetAssembly="Acme, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f66185f16ea61c16">
<Rule name="rule1" feature="msil encryption" exclude="false">
<Target>Methods</Target>
<Pattern>Acme.Engine*</Pattern>
<Description>Enable MSIL Code Encryption in Acme Engine</Description>
</Rule>
</Rules>
<Rules targetAssembly="Acme.Entities, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f66185f16ea61c16">
<Rule name="rule2" feature="control flow" exclude="true">
<Target>Methods</Target>
<Pattern>Acme.Entities.*</Pattern>
<Description>Disable Control Flow Obfuscation for EF classes</Description>
</Rule>
</Rules>
</XmlRules>
</PropertyGroup>
<Babel XmlRules="$(XmlRules)" />Quando usi Babel Obfuscator per elaborare più assembly target in un progetto, puoi specificare a quale assembly target applicare un insieme di regole con l’attributo targetAssembly nelle regole XML. Questo attributo ti permette di indicare un assembly specifico tramite il suo nome completo, che comprende versione, impostazioni cultura e token della chiave pubblica. Se l’attributo targetAssembly è omesso, le regole vengono applicate a tutti gli assembly target definiti nel progetto.
Babel Desktop
Per usare file di regole XML esterni, seleziona l’assembly target sul canvas del progetto e aggiungi i file a RulesFiles nel gruppo File e dipendenze del pannello delle proprietà.
Per scrivere regole inline, apri la vista Regole XML dell’assembly selezionato (la scheda Regole XML del pannello delle proprietà, oppure Impostazioni > Assembly selezionato > Regole XML). L’editor convalida le regole rispetto allo schema XML di Babel e segnala gli errori con riga e colonna, e può aprire e salvare i documenti di regole come file XML.
Le regole inline sono memorizzate nel file di progetto, nella proprietà XmlRules del task Babel, come nell’esempio MSBuild qui sopra, quindi vengono salvate e messe sotto controllo di versione insieme alla configurazione del progetto. Vedi Progetti di offuscamento per sapere come lavorare con i progetti in Babel Desktop.