INNO Setup + Tutorial

por **FullCheats** Qui Fev 18, 2010 9:40 am

Você ja teve vontade de criar seus próprios SETUP's,com seus arquivos criados,como hacker,ou até mesmo virus?!
Então,você veio ao lugar certo!
Com o INNO Setup,você pode fazer tudo isso,em um piscar de olhos,de uma maneira simples!

Indice:

Download do Programa

Tutorial com fotos

Visão geral de um instalador, e noções básicas

Entendendo melhor o arquivo de projeto do Inno Setup

Parâmetros nas seções

Instalação de arquivos: dicas úteis

Protegendo e criptografando o instalador com uma senha

Protegendo com um número serial

Concluindo

Download do Programa

Para fazer o Download de INNO SETUP,clique aqui

Tutorial com Fotos

O Inno Setup é um gerador de programas de instalação para Windows, gratuito e de código aberto. É um dos instaladores mais bem feitos e usados, concorre diretamente com muitos softwares comerciais do tipo.

Voltado a desenvolvedores diversos, ele facilita a criação de um programa de instalação para suas aplicações, com um visual moderno e clássico de instalador, se mantendo prático e cheio de recursos. Ter um instalador próprio mal feito ou feito na correria pode ser ruim para seus programas, é bom preparar uma instalação bem feita – afinal, o primeiro contato dos usuários com seu programa geralmente se dá durante a instalação

Entre várias outras coisas, o Inno Setup permite criar chaves no registro e em arquivos INI, além do básico de um instalador: copiar arquivos para alguma pasta e a criação de atalhos. Ele tem várias propriedades que podem ser configuradas, como limitar a instalação a somente administradores, registrar DLL/OCX, instalar fontes, e muito mais. Ainda cria um desinstalador, que pode remover completamente seu programa. Uma grande possibilidade é que ele tem suporte a uma espécie de “programação” interna, onde você pode personalizar o instalador usando algumas funções como se estivesse num ambiente de programação. É possível também chamar funções de DLLs, ou seja: as possibilidades são imensas.

A geração dos instaladores com o Inno Setup se dá por meio de um script. O compilador dele lê o script e gera um executável, unindo seus arquivos, as configurações e o módulo do instalador (um executável pronto, que realizará a instalação baseando-se nas configurações definidas). O resultado é um único arquivo .exe, que pode ser facilmente distribuído. O instalador dos seus programas terá esta aparência:

A criação do script, que é basicamente um arquivo de texto puro (com a extensão .iss), pode ser feita digitando-se os comandos manualmente ou então usando o assistente de criação do Inno – que gera um projeto básico. A forma mais fácil de criar um novo instalador é usar o assistente, e depois modificar o arquivo do projeto manualmente. E claro, modificar várias vezes, compilar e testar, até ficar pronto

O assistente dele faz o básico, vou me concentrar em mostrar alguns pontos importantes para um bom instalador, como a criação de chaves no registro, e orientação sobre como “programar” no Inno Setup, dando exemplo de uso de uma DLL externa.

O assistente do Inno exibe algumas telas, basta você ir preenchendo com as informações do seu programa e avançando:

Ao final, ele tem um script básico, que você poderá modificar sem grandes dificuldades. Antes de começar, é bom ter organizado e separado os arquivos do seu programa. Deixe tudo o que deverá existir no sistema do usuário em uma pasta, com subpastas, se necessário – toda a estrutura será copiada. Separe também o texto da licença da aplicação, de preferência num arquivo TXT.

Iniciando o compilador do Inno Setup, escolha a opção “Create a new script using the Script Wizard”. Vá preenchendo as informações conforme solicitadas, e ao concluir, terá o script padrão gerado. Considerando que ele é um gerador de programas de instalação para um software que você tenha criado, não haverá dificuldade em passar pelo assistente. Para compilar seu projeto, tecle CTRL+F9, e para compilar e testar, F9 apenas (como no Delphi). Você pode usar os menus ou botões da barra de ferramentas também, claro. O ambiente do Inno funciona como um debugger, mostrando quando algo estiver errado (inclusive indicando a linha), além de exibir um log da instalação em andamento (enquanto você testar o instalador a partir da interface dele). O arquivo para ser distribuído será o setup.exe, que por padrão fica na pasta “Output”, onde estiver salvo o script.

A estrutura básica do script do Inno Setup é esta:

[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
AppId={{4BD6DFD3-105A-4921-B253-3F15E6022B5C}
AppName=My Program
AppVerName=My Program 1.5
AppPublisher=My Company, Inc.
AppPublisherURL=http://www.example.com/
AppSupportURL=http://www.example.com/
AppUpdatesURL=http://www.example.com/
DefaultDirName={pf}My Program
DefaultGroupName=My Program
OutputBaseFilename=setup
Compression=lzma
SolidCompression=yes

[Languages]
Name: "brazilianportuguese"; MessagesFile: "compiler:LanguagesBrazilianPortuguese.isl"

[Tasks]
Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked

[Files]
Source: "C:Program Files (x86)Inno Setup 5ExamplesMyProg.exe"; DestDir: "{app}"; Flags: ignoreversion
; NOTE: Don't use "Flags: ignoreversion" on any shared system files

[Icons]
Name: "{group}My Program"; Filename: "{app}MyProg.exe"
Name: "{commondesktop}My Program"; Filename: "{app}MyProg.exe"; Tasks: desktopicon

[Run]
Filename: "{app}MyProg.exe"; Description: "{cm:LaunchProgram,My Program}"; Flags: nowait postinstall skipifsilent

Veja que o arquivo tem o estilo dos arquivos INI, sendo bem fácil de editar. Algumas seções permitem vários parâmetros, neste caso eles devem ser separados por ponto-e-vírgula, além de terem seu conteúdo declarado entre aspas, se tiver espaços.

A seção [Setup] define informações básicas do programa de instalação, como o nome da aplicação, URL do produtor, pasta padrão para instalação, etc. O Inno Setup usa algumas constantes de pastas próprias; você pode ver uma relação completa na ajuda dele. Por exemplo, {pf} retorna o caminho completo da pasta “Arquivos de programas” no sistema do usuário – independente do idioma do Windows ou partição em que ela esteja. Na seção [Setup], várias coisas podem ser ativadas ou desativadas, como a compressão, a exibição de uma licença de uso, a possibilidade de proteger a instalação com uma senha, entre muitas outras. As entradas nesta seção são simples, sendo basicamente no estilo Diretiva=Opção.

A seção
[Languages]
, como o nome sugere, permite definir os idiomas da instalação. No assistente você pode escolher vários idiomas, ou modificar as entradas aqui, adicionando novas linhas para os idiomas desejados. Por exemplo, para manter o instalador em inglês e português, você colocaria:

[Languages]

Name: "brazilianportuguese"; MessagesFile: "compiler:LanguagesBrazilianPortuguese.isl"

Name: "english"; MessagesFile: "compiler:default.isl"

O “Default.isl” é o arquvio de texto com as mensagens para inglês, ele está na pasta do Inno Setup (por isso pode-se usar “compiler:”, que retorna a pasta do compilador do Inno). O Inno Setup gera instaladores multi-linguagem, e caso tenha mais de um idioma definido, aparecerá uma caixa de diálogo para seleção da linguagem no começo da instalação.

Das outras seções, a [Files] é a mais importante. Ela define as pastas e arquivos que serão instalados no sistema. A [Icons] permite a criação de atalhos, a [Run] a execução de comandos logo após a conclusão da instalação, e a [Tasks] permite criar “tarefas”, itens de checkbox que aparecerão antes de iniciar a instalação, podendo ser marcados ou desmarcados pelo usuário. As entradas nas outras seções referenciando uma tarefa previamente definida na seção [Tasks] só serão executadas se o usuário deixar marcada a opção correspondente, durante a instalação.

O uso do Inno não é difícil, mas você precisa dedicar um tempinho até entender como as entradas do script dele se relacionam. Na pasta “Examples”, dentro da pasta do Inno, existem exemplos básicos sem muitas entradas – permitindo que você estude um assunto por vez. Nesse artigo vou destacar alguns meios de usar o Inno para gerar instaladores mais profissionais e responsáveis, sem ficar usando muito as opções “padrões” apenas.

Visão geral de um instalador, e noções básicas

O instalador é o programa que vai instalar os arquivos e configurações do seu programa no sistema do usuário. É importante que ele seja bem feito, e responsável – que limpe tudo o que fizer, numa desinstalação. Algumas observações que você deve ter em mente:

É recomendável que o programa seja instalado apenas por um administrador. Usuários limitados não podem gravar coisas em chaves globais do registro, nem em pastas do sistema (como a Arquivos de programas). Apesar de ser possível o usuário gravar coisas nas suas pastas pessoais (podendo até instalar o programa nela, se as características da instalação permitir), com a vinda do Windows Vista e o XP, popular com o NTFS por padrão, é bom restringir a instalação aos administradores. No Windows XP com o HD formatado em FAT32, um usuário limitado até pode instalar coisas na Arquivos de programas, mesmo que não possa gravar dados em algumas chaves do registro. Já com o sistema de arquivos NTFS, padrão no Vista também, não tem como ele gravar dados na Arquivos de programas. Nas versões recentes do Inno Setup, por padrão, a instalação só pode ser feita por um administrador. Se quiser permitir que usuários limitados executem seu instalador, então adicione na seção [Setup] esta linha: PrivilegesRequired=none.

Na desinstalação, limpe tudo o que o seu programa colocar, mas tome o cuidado de não apagar arquivos do usuário. O Inno Setup remove uma boa parte do que ele faz na instalação automaticamente. Mas em algumas situações, alguns arquivos podem permanecer no HD. Tome o cuidado de remover estes arquivos (comentarei como logo mais).

Em coisas exclusivas do seu programa (pastas, chaves do registro e atalhos), use um nome que provavelmente só o seu programa use, para evitar conflitos com outros programas que possam existir no sistema do usuário.

Entendendo melhor o arquivo de projeto do Inno Setup

O arquivo de projeto é formado por seções, grupos de opções e configurações. Os nomes das seções são identificados entre colchetes, e aparecem em negrito na tela do compilador. Os itens referentes a uma determinada seção devem estar "dentro" dela. Algumas seções possuem itens como diretivas, idênticas aos arquivos INI. Por exemplo:

[Setup]

AppName=Meu Programa

AppPublisher=Meu nome

Outras seções podem possuir mais parâmetros, geralmente separados por um ponto-e-vírgula. Veja:

[Files]

Source: "MeuPrograma.exe"; DestDir: "{app}"

Não é recomendável especificar duas vezes uma mesma seção, coloque as diretivas ou parâmetros de uma mesma seção embaixo da mesma identificação dela.

Você pode colocar comentários dentro do script. Comentários são textos que não são compilados, eles apenas indicam alguma coisa, em especial para quem irá ler ou trabalhar com o script ("script" é o "texto" do arquivo de projeto). Basta iniciar uma linha com o ponto-e-vírgula:

; Isto é um comentário... Blá, Blá, Blá......

Se você possui um arquivo de projeto com informações que deverão se repetir em várias instalações, pode utilizar a diretiva #include. O conteúdo do arquivo indicado será inserido no local especificado, e após ele as informações que estiverem serão continuadas, como se fossem um arquivo só. A sintaxe é:

#include "meuarquivo.iss"

A extensão não precisa ser necessariamente .iss, pode ser outra se você quiser, como .txt, por exemplo.

O arquivo informado deverá estar na mesma pasta do arquivo de projeto, ou então você pode informar o caminho completo (por exemplo, "C:Minha pastaMeu arquivo.iss"). Se o arquivo estiver na mesma pasta do compilador, você pode utilizar assim: #include compiler:teste.iss. Aliás, "compiler:" será substituído pelo caminho da pasta do compilador, em diversas seções.

Parâmetros nas seções

Todas as seções do arquivo de projeto, com exceção de [Setup], [Messages], [CustomMessages], e [LangOptions], contém linhas separadas em parâmetros. Veja o seguinte exemplo, da seção [Files]:

[Files]

Source: "MEUPROGRAMA.EXE"; DestDir: "{app}"

Source: "AJUDA.HLP"; DestDir: "{app}"

Source: "LEIAME.TXT"; DestDir: "{app}"; Flags: isreadme

Cada parâmetro consiste em um nome, seguido por um identificador, e então um valor. Exceto em alguns poucos casos, os parâmetros são opcionais. Eles assumirão um valor padrão se não forem especificados. Múltiplos parâmetros em uma linha podem ser separados por ponto-e-vírgula, e podem estar em qualquer ordem.

Geralmente se utilizam aspas duplas (") para definir o valor de um parâmetro definido pelo usuário, como por exemplo o nome de um arquivo. Usar aspas quase sempre não é obrigatório, mas é necessário quando o valor tiver espaços.

Se precisar utilizar aspas duplas em alguma definição, coloque duas aspas duplas consecutivas, para evitar conflito com as aspas delimitadoras do parâmetro. A linha a seguir:

"Este exemplo ""contém aspas"" embutidas"

Ficaria assim, após a compilação:

Este exemplo "contém aspas" embutidas

Se você quiser que o valor de um parâmetro seja uma única aspa dupla, utilize então quatro caracteres de aspas duplas: """". Os caracteres das extremidades cercam o valor como sendo um valor definido pelo usuário, e os dois do meio são para gerar um único caractere de aspa.

Instalação de arquivos: dicas úteis

O assistente de criação de script do Inno cria uma entrada para cada arquivo que você adicionar, na seção [Files]. Por exemplo:

[Files]

Source: "C: programaPrograma.exe"; DestDir: "{app}"; Flags: ignoreversion

Source: "C: programaLeiame.txt"; DestDir: "{app}"; Flags: ignoreversion

Source: "C: programaFunções.dll"; DestDir: "{app}"; Flags: ignoreversion

Conforme você for tendo muitos arquivos, ou pastas e subpastas, essa idéia pode ficar confusa. A minha recomendação é criar uma pasta e deixar nela todos os arquivos do seu programa, incluindo subpastas, exatamente como você quer que eles fiquem na pasta do seu programa no sistema dos usuários. Assim, a seção [Files] teria uma entrada só:

[Files]

Source: "C: programa*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs

Protegendo e criptografando o instalador com uma senha

O Inno Setup pode proteger a instalação com uma senha, é uma medida de “segurança” básica. A senha não é a mesma coisa de um número serial, apesar de ter função parecida: sem ela, não será possível continuar a instalação. É simples, basta definir a diretiva Password na seção [Setup]:

Password=teste

A tela que pede a senha para o usuário será assim:

A senha não será gravada no arquivo diretamente, mas sim um hash (sombra) dela. Os arquivos, o conteúdo do instalador em si, não estarão “protegidos”: eles não são encriptados por padrão. Você pode forçar uma encriptação usando a diretiva Encryption, ativando-a com “yes” na seção [Setup]:

Password=teste
Encryption=yes

Para isso, uma DLL com a função de criptografia do Inno deverá ser colocada na pasta do Inno Setup. Ele não inclui o suporte “nativo” à criptografia devido a legislação de alguns países. Basta baixar a DLL em:

http://www.jrsoftware.org/isdl.php

E colocá-la na pasta do Inno (normalmente Arquivos de programas Inno Setup). Não se preocupe em redistribui-la com o seu programa, não será necessário. Com a criptografia ativada, o conteúdo do instalador será codificado usando como base a senha escolhida, e então o arquivo estará protegido (mesmo que alguém consiga acesso ao pacote de dados dentro do instalador – o que não é difícil, visto que o Inno Setup é open source – não poderá fazer nada com os arquivos, pois estarão criptografados).

Protegendo com um número serial

A proteção por número serial é um recurso possível no Inno Setup, mas não “diretamente”. Com a diretiva UserInfoPage=yes na seção [Setup], ele mostra uma tela para digitação de um nome de usuário e organização. Mas não um número serial. O nome e a organização poderão ser recuperados com as constantes {userinfoname} e {userinfoorg}, podendo ser gravados no registro, num arquivo INI ou então passados como parâmetro para algum programa (usando a seção [Run], deixando a constante {userinfoname} ou {userinfoorg} como parâmetro para o seu executável).

Para que apareça o campo de número serial, você deverá usar a seção [Code]. O Inno Setup, a partir da versão 4, permite a codificação usando o Pascal Script. É uma linguagem de script baseada em Pascal, muito parecida com o Delphi. Você pode “programar” dentro do Inno, executar funções personalizadas em algumas situações e inclusive chamar funções em DLLs – suas ou não.

A seção [Code] é um pouco complexa para entender de imediato, ela contém funções e rotinas próprias que se aplicam apenas ao Inno Setup, assim como contém funções comuns a outros ambientes (principalmente ao Delphi; a saber, o Inno Setup é feito em Delphi). Para verificação de número serial, você deve criar a seção [Code] no script do Inno, e colocar a função CheckSerial. Esta função tem esta sintaxe:

function CheckSerial(Serial: String): Boolean;

O que ela faz? Ela recebe o serial preenchido pelo usuário, que é passado como string, e deve devolver um valor booleano (sim ou não), para liberar ou não a instalação. Para implementá-la, coloque no final do arquivo de script do Inno Setup:

[Code]

function CheckSerial(Serial: String): Boolean;

begin
end;

Entre o begin e o end você pode fazer literalmente o que quiser, como se estivesse num ambiente de programação. As funções internas providas com o Inno Setup são básicas, mas você poderá chamar DLLs, como explico já já.

Para validar o serial rapidamente, você poderia colocar:

function CheckSerial(Serial: String): Boolean;

begin
if Serial = '123456' then

Result := True

else
Result := False;

end;

Isso limita a instalação ao serial “123456”. Experimente compilar o instalador e testar

Não se esqueça de ativar a tela de informações do usuário, colocando UserInfoPage=yes, na seção [Setup].

Se você quiser, pode implementar um pouco mais, e testar também o nome de usuário e a organização preenchidos. Para isso, precisará usar variáveis e a função ExpandConstant, que expande uma constante do Inno, retornando o valor dela como string:

function CheckSerial(Serial: String): Boolean;

var

usu, org: String;

begin
usu := ExpandConstant('{userinfoname}');

org := ExpandConstant('{userinfoorg}');

if (usu = 'Marcos') and (org = 'Guia do Hardware') and (Serial = '123456') then

Result := True

else
Result := False;

end;

Coloquei assim por motivos didáticos, nada impede que você simplifique a verificação do if, deixando-o apenas assim:

Result := (usu = 'Marcos') and (org = 'Guia do Hardware') and (Serial = '123456');

Uma observação importante no Inno Setup, é que esta função é chamada para cada caractere que o usuário digitar. Se você inventar algum algoritmo de verificação diabólico que coma muito processamento, a digitação do serial pelo usuário ficará “lenta”. Ele chama a função ao digitar, pois libera o botão “Avançar” apenas se a informação estiver correta. Enquanto a função CheckSerial retornar False, o botão Avançar fica desativado.

Nada impede que algum “hacker” manipule o estado do botão Next do Inno Setup, usando aplicações de terceiros, e parta para a próxima tela sem digitar o número serial. O recurso é interessante, mas deve ser usado com cuidado. O Inno é um projeto aberto, suas especificações são claras e qualquer um munido de conhecimentos avançados pode manipular a função CheckSerial para sempre retornar True. A recomendação seria usar um sistema de registro externo ao Inno, com um algoritmo criado por você, e talvez usar o campo de serial apenas para a inserção do serial e posterior processamento – algo que pode ser útil dado o visual do instalador, ficaria mais “tradicional” solicitar o número serial durante a instalação. Uma proteção maior pode se dar usando a senha com criptografia ativada, como comentado mais acima – onde mesmo se o “hacker” burlar o sistema e conseguir avançar, os arquivos estarão altamente corrompidos sem a senha certa, e não servirão para nada.

Concluindo

Eis um pouco do Inno Setup. Ele ainda pode ser personalizado, de várias formas: além do uso de DLLs, é possível adicionar páginas (telas de instalação) personalizadas, para obter dados adicionais do usuário durante a instalação. Ou você pode ir mais longe, baixando o código fonte do Inno e alterando diretamente os arquivos do instalador – o que não é fácil, mas pode ser uma experiência interessante. Ele foi feito em Borland Delphi, e é compilado pelo Jordan Russell no velho Delphi 2 – já que as versões antigas do Delphi geram executáveis bem pequenos, perto das versões recentes

Se você não gosta de manipular o script diretamente, pode experimentar o ISTool, uma interface gráfica para o Inno Setup, que permite criar e modificar os arquivos .iss facilmente:

============================================

O que acharam pessoal? Gostaram?

Créditos:

ℛiqu∊
Guia do Hardware - Acesse!