Arquivos com a Tag: Maycon Roberto

Segurança em Aplicações Mobile: Lock Wipe no Windows Mobile [Parte 1/2 Wipe]

Postado por
Comoentário

No meu post anterior foi abordado o assunto de Lock e Wipe no Android. Hoje, nosso objetivo é mostrar como realizar o Wipe no Windows Mobile, sistema operacional de mobilidade da Microsoft que, embora sendo uma plataforma sem expressividade nos smartphones modernos comercializados atualmente, ainda é muito importante no meio corporativo. Por isso é que vamos mostrar como realizar o Wipe nessa plataforma. Você deve estar se perguntando: e o Lock? Bom, em se tratando de Windows Mobile, a implementação do Lock é bem diferente em relação ao Wipe, por isso, achei melhor, primeiro, mostrar como se implementa o Wipe e, posteriormente, será mostrado como realizar o Lock, para quem tiver interesse em aprender sobre esse assunto.

Conceito

O conceito de Wipe, que também é chamado de Hard Reset de dispositivo, é o processo pelo qual são apagados todos os dados armazenados no dispositivo e suas configurações originais são restauradas. O Wipe funciona em dispositivos com Windows Mobile 5 ou superior.

Criando XML de configuração

O Windows Mobile permite configurações personalizadas através de arquivos XML especiais, contendo difinições específicas sobre uma determinada configuração que se queira aplicar no dispositivo. Obviamente que o formato do XML segue uma estrutura padronizada pela Microsoft. Você poderá ter mais detalhes dessa arquitetura clicando aqui. Também a aplicação desse XML de configuração no dispositivo se dá programaticamente.

Como nosso foco é aplicar o Wipe no dispositivo, segue abaixo o XML responsável pela sua execução:

<wap-provisioningdoc>
   <characteristic type='RemoteWipe'>
      <parm name='doWipe' value='1'/>
   </characteristic>
</wap-provisioningdoc>

Uma maneira simples de criar instâncias de XML é usar a classe XmlDocument, contida no namespace System.Xml. Um exemplo de como utilizá-la encontra-se logo abaixo:

string strXml = @"<wap-provisioningdoc>
                     <characteristic type='RemoteWipe'>
                        <parm name='doWipe' value='1'/>
                     </characteristic>
                  </wap-provisioningdoc>";
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(strXml);

Pronto. Já temos à mão nossa instância de XML capaz de aplicar o Wipe em dispositivos baseados em Windows Mobile. Mas, como vamos fazer isso?

Classe ConfigurationManager

Para aplicar uma determinada configuração via XML em um dispositivo, precisamos utilizar a classe ConfigurationManager, que se encontra disponível no namespace Microsoft.WindowsMobile. Essa classe contém o método que nos interessa: ConfigurationManager.ProcessConfiguration. Esse método é responsável por processar um XML de configuração no dispositivo.
No nosso exemplo, teríamos algo assim:

ConfigurationManager.ProcessConfiguration(xmlDocument, true);

Para maiores informações dessa classe, clique aqui.

Etapa Final

Para efetivarmos o Wipe do dispositivo, precisamos fazer uma chamada de método via PInvoke, que significa chamar um método de uma dll nativa do Windows Mobile. Isso se faz necessário, pois o método que vamos precisar chamar não se encontra disponível no .NET Compact Framework. A dll que nos interessa é a Core.dll. Para chamar algum método dessa dll, precisamos referenciá-la em nosso código, no escopo da classe, como mostrado a seguir:

[DllImport("coredll")]
private static extern void SetCleanRebootFlag();

Após isso, já podemos chamar o método SetCleanRebootFlag() em nosso código. É importante a chamada desse método após processarmos o XML contendo a definição de Wipe, para que o dispositivo reinicie efetivamente, restaurando suas configurações originais.

O próximo post abordará a questão do Lock de dispositivos baseados em Windows Mobile. Não percam! Até mais!

Escrito por Maycon Roberto

Segurança em Aplicações Mobile: Lock e Wipe no Android

Postado por
Comoentário

Com o uso cada vez mais frequente de dispositivos móveis, inclusive  em ambientes corporativos,  há uma preocupação que cresce proporcionalmente: como apagar os dados armazenados nos dispositivos que foram extraviados  e como impedir a utilização de um dispositivo por pessoas não autorizadas.

Pensando nisso, as principais plataformas de mobilidade da atualidade têm oferecido recursos em nível de programação para que seja possível a implementação de soluções capazes de bloquear um dispositivo contra acessos não autorizados e eliminar os dados armazenados no dispositivo, restaurando suas configurações originais. O conceito de Lock e Wipe aborda essa duas características.

Hoje vamos apresentar a maneira como implementamos o Lock e Wipe na plataforma Android. Essa funcionalidade está disponível a partir do API Level 8, ou seja, a versão 2.2 do Android.

Atenção!

Para que seja possível uma aplicação realizar qualquer uma dessas duas operações, primeiro é preciso dar permissão de administrador à aplicação.  Essa permissão quem concede é o próprio usuário, porém, a chamada da tela solicitando a confirmação do usuário é de responsabilidade da própria aplicação. Sua aplicação deve ter um mecanismo capaz de verificar se este tem privilégio de administrador e, não tendo, saber chamar a tela apropriada solicitando a confirmação do usuário. Mostraremos como fazer isso mais adiante.

Colocando a mão na massa

Nosso objetivo aqui é dar uma noção geral de como podemos implementar as operações de Lock e Wipe em um dispositivo com Android.
O primeiro passo é configurar o arquivo Manifest.xml. Precisamos incluir as seguintes tags nele:

<receiver android:name="android.app.admin.DeviceAdminReceiver"
          android:label="device_admin" android:permission="android.permission.BIND_DEVICE_ADMIN">
   <meta-data android:name="android.app.device_admin"
              android:resource="@xml/device_admin" />
   <intent-filter>
      <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
      <data android:scheme="@string/app_name" />
   </intent-filter>
</receiver>

Como visto acima, precisamos declarar um Receiver, que será responsável pela efetiva execução do Lock e Wipe no dispositivo. Vamos destacar as partes mais importantes dessas tags:

  • receiver Android:name: aqui deverá constar sua classe do tipo BroadCastReceiver, que deverá ser filha da classe android.app.admin.DeviceAdminReceiver, ou ela própria.
  • receiver android.permission: permissão que deverá ser dada ao Receiver responsável pela administração do dispositivo (Receiver declarado no atributo acima). Essa permissão garante que somente o sistema interagirá com ele.
  • meta-data android:resource: essa propriedade é interessante. Você deverá criar um arquivo xml incluindo as ações que seu aplicativo poderá fazer, por ser administrador do dispositivo, e referenciá-lo nessa propriedade. Abaixo um exemplo do conteúdo desse arquivo, indicando somente as ações de lock e wipe: 
    <device-admin xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-policies>
    <force-lock />
    <wipe-data />
  </uses-policies>
</device-admin>

  • action android:name: Aqui é configurado a Intent que será chamada pela sua aplicação para que o usuário conceda privilégio de administrador à sua aplicação. Abaixo é mostrado um exemplo de como chamar essa Intent em sua aplicação:

    /*
 *Intancia um ComponentName com o contexto em questão (MyClass.this)
 *e com o Receiver declarado no Manifest.xml
 */
ComponentName appAdmin = new ComponentName(MyClass.this,
          DeviceAdminReceiver.class);

Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN,
                appAdmin );
intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                "Texto adicional explicando o motivo da solicitação");
startActivityForResult(intent, 1);

Após todo esse processo, agora vamos mostrar como é realizado o Lock e Wipe programaticamente.

Aplicando o Lock e Wipe

A classe que expõe os métodos responsáveis pelas operações de Lock e Wipe no Android é a classe android.app.admin.DevicePolicyManager. A operação de Wipe consiste em inicializar o dispositivo, excluindo todos os dados armazenados nele e restaurando as configurações originais. Já a operação de Lock consiste em bloquear o dispositivo contra o uso não autorizado, sendo possível desbloqueá-lo caso a senha inserida seja a correta. Uma peculiaridade, nesse caso, é que podemos inclusive alterar a senha via programação, mesmo já existindo uma senha cadastrada previamente pelo usuário referente ao bloqueio.
Antes de chamar os métodos precisamos instanciar a classe DevicePolicyManager. Abaixo segue o exemplo de como fazemos isso:

//MyContext = contexto em questão
DevicePolicyManager policeManager = (DevicePolicyManager)
      MyContext.getSystemService(Context.DEVICE_POLICY_SERVICE);

Após instanciar a classe, já podemos chamar os métodos responsáveis pelas operações. Mostraremos como isso é feito:

Wipe:

 policeManager.wipeData(0);

 
Lock:

 policeManager.lockNow();

 

Como podemos perceber, não há dificuldades para entender e utilizar esse recurso que é muito útil, principalmente nos dias atuais, onde os dados contidos nos dispositivos são muito mais valiosos  do que os próprios dispositivos. Não perca nossos próximos posts sobre Lock e Wipe, pois queremos abordar esse recurso também em outras plataformas móveis. Para maiores informações sobre Lock e Wipe no Android clique Aqui. Até Mais!

Escrito por Maycon Roberto