Todos os registros são bastante auto-explicativo com exceção do campo ID. Vamos usá-lo para apresentar o evento desejado.
Uma vez que o banco de dados é feita, você precisa para criar suas páginas ASP. Neste exemplo, vamos usar quatro páginas; calendar.asp, display_event.asp, add_event.asp e edit_event.asp. Você poderia provavelmente começar afastado com apenas duas páginas, mas para a facilidade de uso, vamos criar quatro.
Vamos começar com a página calendar.asp.

<–#include file=”adovbs.inc”–>

Dim DB_CONNECTIONSTRING

Dim objRecordset

DB_CONNECTIONSTRING = “DRIVER={Microsoft Access Driver (*.mdb)};DBQ=” & _

Server.Mappath(“users.mdb”) & “;”

Set objRecordset = Server.CreateObject(“ADODB.Recordset”)

objRecordset.Open “calendar”, DB_CONNECTIONSTRING, adOpenStatic, adLockPessimistic, adCmdTable

Essa parte do código que escreve os dias do calendário e inserir os assuntos de nosso banco de dados com um link para a página display_event.asp. Isso dará a usuários a clicar em algo para veiw todo o evento.

If Not objRecordset.BOF Then

‘– Mover para o primeiro registro

objRecordset.MoveFirst

Do Until objRecordset.EOF

If objRecordset.Fields(“Year”) = Year(dDate) Then

If objRecordset.Fields(“Month”) = Month(dDate) Then

If objRecordset.Fields(“Day”) = iCurrent Then

‘– Se tudo coincide com o dia atual, em seguida, exibir
‘o sujeito com o ID coresponding –

Response.Write(“<br><font size=2><a href=” & _

Chr(34) & “display_event.asp?ID=” & _

objRecordset.Fields(“ID”) & Chr(34) & “>” & _

objRecordset.Fields(“Subject”) & _

“</a></font><br>”)

End If

End If

End If

‘– Se nada corresponde, passar para o próximo registro e
‘começar tudo de novo –

objRecordset.MoveNext

Loop

End If

Temos agora apresentado o tema do evento correto com o ID de evento anexado na URL como uma seqüência de consulta (ex. display_event.asp? ID = 10). Quando o usuário clica sobre o tema do evento, passamos o ID de evento para a página display_event.asp.
Que nos leva à página do evento. Você precisa primeiro se conectar ao banco de dados (o mesmo que acima). Então você precisa para obter o ID de eventos a partir da seqüência de consulta e percorrer o banco de dados até encontrarmos o evento:

EventToShow = CInt(Request.QueryString(“ID”))

If Not objRecordset.EOF Then

objRecordset.MoveFirst

Do Until objRecordset.Fields(“ID”) = EventToShow

objRecordset.MoveNext

Loop

End If

Em seguida, deseja correlacionar o evento exibido com uma variável de sessão para editar e exibir o evento::

Session(“EventToEdit”) = EventToShow

Date:

<%

Response.Write objRecordset.Fields(“Month”) & “/” & _

objRecordset.Fields(“Day”) & “/” & _

objRecordset.Fields(“Year”)

%>

Subject:

<%

Response.Write objRecordset.Fields(“Subject”)

%>

Message: <%= objRecordset.Fields(“Message”) %>

Added By:

<%

Response.Write objRecordset.Fields(“AddedBy”) & _

” on ” & objRecordset.Fields(“DateAdded”)

%>

Não se esqueça de limpar a sua conexão com o banco:

objRecordset.Close
Set objRecordset = Nothing

As próximas duas páginas (edit_event.asp & add_event.asp) são muito semelhantes. A única exceção é que com o evento de edição, queremos mostrar o evento existente dentro do formulário. Como mencionei anteriormente, você poderia provavelmente começar com a combinação destas duas páginas. A única coisa que você precisa manter em mente é com a manipulação do recorset. Na página de atualização, precisamos usar objRecordset.Update, enquanto na página add_event.asp, você vai querer usar objRecordset.AddNew.
Em ambos os casos, precisamos conectar ao banco de dados de entrada e os dados do formulário para os campos, semelhante ao abaixo:

objRecordset.Fields(“Subject”) = Request.Form(“txtSubject”)
objRecordset.Fields(“Message”) = Request.Form(“Message”)
objRecordset.Fields(“Day”) = Request.Form(“txtDay”)
objRecordset.Fields(“Month”) = Request.Form(“txtMonth”)
objRecordset.Fields(“Year”) = Request.Form(“txtYear”)
objRecordset.Fields(“AddedBy”) = Request.Form(“txtAddedBy”)
objRecordset.Fields(“DateAdded”) = Now()

Há obviamente muito mais que você pode fazer com este exemplo, mas isso vai lhe proporcionar um bom ponto de partida. Você pode querer só permitem aos usuários editar / excluir eventos que eles postaram (este é onde o campo AddedBy vem no lugar). Você também pode querer inserir um tempo para o evento. Você poderia código de evento de cor os dias que têm eventos postados.Abaixo todos os códigos das págins.

add_event.asp

<%@ LANGUAGE=VBSCRIPT %>

<%Option Explicit%>

<%

Dim DB_CONNECTIONSTRING

Dim objRecordset

Dim Added

%>

<!–#include file=”adovbs.inc”–>

<%

DB_CONNECTIONSTRING = “DRIVER={Microsoft Access Driver (*.mdb)};DBQ=” & Server.Mappath(“users.mdb”) & “;”

Set objRecordset = Server.CreateObject(“ADODB.Recordset”)

objRecordset.Open “calendar”, DB_CONNECTIONSTRING, adOpenStatic, adLockPessimistic, adCmdTable

If Request.Form(“btnAdd”) = “Add Event” Then

objRecordset.AddNew

‘– Adiciona records no database do form –

objRecordset.Fields(“Subject”) = Request.Form(“txtSubject”)

objRecordset.Fields(“Message”) = Request.Form(“Message”)

objRecordset.Fields(“Day”) = Request.Form(“selDay”)

objRecordset.Fields(“Month”) = Request.Form(“selMonth”)

objRecordset.Fields(“Year”) = Request.Form(“selYear”)

objRecordset.Fields(“AddedBy”) = Request.Form(“txtAddedBy”)

objRecordset.Fields(“DateAdded”) = Now()

objRecordset.Update

Added = “True”

End If

objRecordset.Close

Set objRecordset = Nothing

If Added = “True” Then

Response.Redirect(“calendar.asp”)

End If

%>

<html>

<center>

<form method=”post” action=”add_event.asp”>

<table border=”0″ cellpadding=”0″ cellspacing=”0″>

<tr>

<td>Dia:

<select name=”selDay”>

<option value=”1″>1</option>

<option value=”2″>2</option>

<option value=”3″>3</option>

<option value=”4″>4</option>

<option value=”5″>5</option>

<option value=”6″>6</option>

<option value=”7″>7</option>

<option value=”8″>8</option>

<option value=”9″>9</option>

<option value=”10″>10</option>

<option value=”11″>11</option>

<option value=”12″>12</option>

<option value=”13″>13</option>

<option value=”14″>14</option>

<option value=”15″>15</option>

<option value=”16″>16</option>

<option value=”17″>17</option>

<option value=”18″>18</option>

<option value=”19″>19</option>

<option value=”20″>20</option>

<option value=”21″>21</option>

<option value=”22″>22</option>

<option value=”23″>23</option>

<option value=”24″>24</option>

<option value=”25″>25</option>

<option value=”26″>26</option>

<option value=”27″>27</option>

<option value=”28″>28</option>

<option value=”29″>29</option>

<option value=”30″>30</option>

<option value=”31″>31</option>

</select></td>

<td>Mês:

<select name=”selMonth”>

<OPTION VALUE=”1″>Janeiro</option>

<OPTION VALUE=”2″>Fevereiro</option>

<OPTION VALUE=”3″>Março</option>

<OPTION VALUE=”4″>Abril</option>

<OPTION VALUE=”5″>Maio</option>

<OPTION VALUE=”6″>Junho</option>

<OPTION VALUE=”7″>Julho</option>

<OPTION VALUE=”8″>Agosto</option>

<OPTION VALUE=”9″>Setembro</option>

<OPTION VALUE=”10″>Outubro</option>

<OPTION VALUE=”11″>Novembro</option>

<OPTION VALUE=”12″>Dezembro</option>

</select></td>

<td>Ano:

<select name=”selYear”>

<option value=”1999″>1999</option>

<option value=”2000″>2000</option>

<option value=”2001″>2001</option>

<option value=”2002″>2002</option>

<option value=”2003″>2003</option>

<option value=”2004″>2004</option>

</select></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”>Assunto:

<input type=”text” name=”txtSubject” size=”35″></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”><textarea name=”Message” cols=”40″ rows=”10″></textarea></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”>Adicionado por:

<input type=”text” name=”txtAddedBy” size=”35″ value=”<%= Session(“FirstName”) & ” ” & Session(“LastName”)%>”></td>

</tr>

</table>

<p>

<input type=”submit” name=”btnAdd” value=”Adiciona”>&nbsp;&nbsp;<input type=”Reset” name=”btnReset” value=”Limpar”>

</form>

</center>

</body>

</html>

Aqui a página calendar.asp

<%@ LANGUAGE=VBSCRIPT %>

<%Option Explicit%>

<!–#include file=”adovbs.inc”–>

<%

If Request.Form(“AddEvent”) = “Add Event” Then

Response.Redirect(“add_event.asp”)

End If

If Request.Form(“EditEvent”) = “Edit Event” Then

Response.Redirect(“edit_event.asp”)

End If

Dim DB_CONNECTIONSTRING

Dim objRecordset

DB_CONNECTIONSTRING = “DRIVER={Microsoft Access Driver (*.mdb)};DBQ=” & Server.Mappath(“users.mdb”) & “;”

Set objRecordset = Server.CreateObject(“ADODB.Recordset”)

objRecordset.Open “calendar”, DB_CONNECTIONSTRING, adOpenStatic, adLockPessimistic, adCmdTable

%>

<%

Function GetDaysInMonth(iMonth, iYear)

Select Case iMonth

Case 1, 3, 5, 7, 8, 10, 12

GetDaysInMonth = 31

Case 4, 6, 9, 11

GetDaysInMonth = 30

Case 2

If IsDate(“February 29, ” & iYear) Then

GetDaysInMonth = 29

Else

GetDaysInMonth = 28

End If

End Select

End Function

Function GetWeekdayMonthStartsOn(iMonth, iYear)

GetWeekdayMonthStartsOn = WeekDay(CDate(iMonth & “/1/” & iYear))

End Function

Function SubtractOneMonth(dDate)

Dim iDay, iMonth, iYear

iDay = Day(dDate)

iMonth = Month(dDate)

iYear = Year(dDate)

If iMonth = 1 Then

iMonth = 12

iYear = iYear – 1

Else

iMonth = iMonth – 1

End If

If iDay > GetDaysInMonth(iMonth, iYear) Then iDay = GetDaysInMonth(iMonth, iYear)

SubtractOneMonth = CDate(iMonth & “-” & iDay & “-” & iYear)

End Function

Function AddOneMonth(dDate)

Dim iDay, iMonth, iYear

iDay = Day(dDate)

iMonth = Month(dDate)

iYear = Year(dDate)

If iMonth = 12 Then

iMonth = 1

iYear = iYear + 1

Else

iMonth = iMonth + 1

End If

If iDay > GetDaysInMonth(iMonth, iYear) Then iDay = GetDaysInMonth(iMonth, iYear)

AddOneMonth = CDate(iMonth & “-” & iDay & “-” & iYear)

End Function

Dim dDate     ‘ Data estamos exibindo calendário para

Dim iDIM      ‘ Dias no mês

Dim iDOW      ‘ Dia da semana que começa no mês

Dim iCurrent  ‘ Variável que usamos para segurar dia atual do mês como nós escrevemos tabela

Dim iPosition ‘ Variável que usamos para manter a posição atual na tabela

If IsDate(Request.QueryString(“date”)) Then

dDate = CDate(Request.QueryString(“date”))

Else

If IsDate(Request.QueryString(“month”) & “-” & Request.QueryString(“day”) & “-” & Request.QueryString(“year”)) Then

dDate = CDate(Request.QueryString(“month”) & “-” & Request.QueryString(“day”) & “-” & Request.QueryString(“year”))

Else

dDate = Date()

If Request.QueryString.Count <> 0 Then

Response.Write “a data que você escolheu não era uma data válida. O calendário foi definido para a data de hoje.<BR><BR>”

End If

End If

End If

iDIM = GetDaysInMonth(Month(dDate), Year(dDate))

iDOW = GetWeekdayMonthStartsOn(Month(dDate), Year(dDate))

%>

<html>

<center>

<table border=”1″ cellspacing=”0″ cellpadding=”1″>

<tr>

<td bgcolor=”blue” align=”center” colspan=”7″>

<table width=”100%” border=”0″ cellspacing=”0″ cellpadding=”0″>

<tr>

<td align=”right”><b><A HREF=”calendar.asp?date=<%= SubtractOneMonth(dDate) %>” style=”color: #FFFFFF”>&lt;–</A></b></TD>

<td align=”center”><font color=”#FFFFFF”><B><%= MonthName(Month(dDate)) & “  ” & Year(dDate) %></B></font></TD>

<td align=”left”><b><A HREF=”calendar.asp?date=<%= AddOneMonth(dDate) %>” style=”color: #FFFFFF”>–&gt;</A></b></TD>

<td align=”right” valign=”top”><a href=”http://www.4guysfromrolla.com”><img src=”close.gif” border=”0″></a></td>

</tr>

</TABLE>

</td>

</tr>

<tr bgcolor=”blue”>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Dom</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Seg</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Ter</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Qua</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Qui</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Sex</font></B></TD>

<td ALIGN=”center” width=”80″><B><font color=”#FFFFFF”>Sab</font></B></TD>

</tr>

<%

If iDOW <> 1 Then

Response.Write(vbTab & “<tr>” & vbCrLf)

iPosition = 1

Do While iPosition < iDOW

Response.Write(vbTab & vbTab & “<td>&nbsp;</td>” & vbCrLf)

iPosition = iPosition + 1

Loop

End If

‘– Escreva dia do mês em slots bom dia –

iCurrent = 1

iPosition = iDOW

Do While iCurrent <= iDIM

‘– opeabre a tabela –

If iPosition = 1 Then

Response.Write(vbTab & “<tr>” & vbCrLf)

End If

‘– Write na data e assun –to

Response.Write(vbTab & vbTab & “<td align=left valign=top height=60><b>” & iCurrent & “</b>”)

If Not objRecordset.BOF Then

objRecordset.MoveFirst

Do Until objRecordset.EOF

If objRecordset.Fields(“Year”) = Year(dDate) Then

If objRecordset.Fields(“Month”) = Month(dDate) Then

If objRecordset.Fields(“Day”) = iCurrent Then

Response.Write(“<br><font size=2><a href=” & Chr(34) & “display_event.asp?ID=” & objRecordset.Fields(“ID”) & Chr(34) & “>” & objRecordset.Fields(“Subject”) & “</a></font><br>”)

End If

End If

End If

objRecordset.MoveNext

Loop

End If

Response.Write(“</td>” & vbCrLf)

‘– Fecha a tabela –

If iPosition = 7 Then

Response.Write vbTab & “</tr>” & vbCrLf

iPosition = 0

End If

‘– Incrementa as  variaveis –

iCurrent = iCurrent + 1

iPosition = iPosition + 1

Loop

If iPosition <> 1 Then

Do While iPosition <= 7

Response.Write(vbTab & vbTab & “<td>&nbsp;</td>” & vbCrLf)

iPosition = iPosition + 1

Loop

Response.Write vbTab & “</TR>” & vbCrLf

End If

%>

</table>

<%

objRecordset.Close

Set objRecordset = Nothing

%>

<%

Response.Write(“<form action=” & Chr(34) & “calendar.asp” & Chr(34) & ” method=” & Chr(34) & “post” & Chr(34) & “>” & Chr(10))

Response.Write(“<input type=” & Chr(34) & “submit” & Chr(34) & ” name=” & Chr(34) & “AddEvent” & Chr(34) & ” value=” & Chr(34) & “Add Event” & Chr(34) & “>” & “&nbsp;&nbsp;”)

Response.Write(“</form>”)

%>

</center>

</body>

</html>

Display_event.asp

<%@ LANGUAGE=VBSCRIPT %>

<%Option Explicit%>

<%

Dim MyName

Dim DB_CONNECTIONSTRING

Dim objRecordset

Dim EventToShow

%>

<!–#include file=”adovbs.inc”–>

<%

MyName = Session(“Firstname”) & ” ” & Session(“LastName”)

DB_CONNECTIONSTRING = “DRIVER={Microsoft Access Driver (*.mdb)};DBQ=” & Server.Mappath(“users.mdb”) & “;”

Set objRecordset = Server.CreateObject(“ADODB.Recordset”)

objRecordset.Open “calendar”, DB_CONNECTIONSTRING, adOpenStatic, adLockPessimistic, adCmdTable

EventToShow = CInt(Request.QueryString(“ID”))

If Not objRecordset.EOF Then

objRecordset.MoveFirst

Do Until objRecordset.Fields(“ID”) = EventToShow

objRecordset.MoveNext

Loop

End If

Session(“EventToEdit”) = EventToShow

%>

<html>

Data:</b> <%= objRecordset.Fields(“Month”) & “/” & objRecordset.Fields(“Day”) & “/” & objRecordset.Fields(“Year”) %><p>

<b>Assunto:</b> <%= objRecordset.Fields(“Subject”) %><p>

<b>Mensagem:</b> <%= objRecordset.Fields(“Message”) %><p>

<b>Adicionado por:</b> <%= objRecordset.Fields(“AddedBy”) & ” on ” & objRecordset.Fields(“DateAdded”)%>

<p>&nbsp;</p>

<form method=”post” action=”edit_event.asp”>

<input type=”submit” name=”btnEditEvent” value=”Edita/Exclui Evento”>

</form>

</body>

</html>

<%

objRecordset.Close

Set objRecordset = Nothing

%>

Edit_event.asp

<%@ LANGUAGE=VBSCRIPT %>

<%Option Explicit%>

<%

Dim DB_CONNECTIONSTRING

Dim objRecordset

Dim Updated

%>

<!–#include file=”adovbs.inc”–>

<%

If Request.Form(“btnCalendar”) = “Back To Calendar” Then

Response.Redirect(“calendar.asp”)

End If

DB_CONNECTIONSTRING = “DRIVER={Microsoft Access Driver (*.mdb)};DBQ=” & Server.Mappath(“users.mdb”) & “;”

Set objRecordset = Server.CreateObject(“ADODB.Recordset”)

objRecordset.Open “calendar”, DB_CONNECTIONSTRING, adOpenStatic, adLockPessimistic, adCmdTable

If Session(“EventToEdit”) <> 0 Then

If Not objRecordset.EOF Then

objRecordset.MoveFirst

Do Until objRecordset.Fields(“ID”) = Session(“EventToEdit”)

objRecordset.MoveNext

Loop

End If

End If

If Request.Form(“btnEdit”) = “Update” Then

‘– Adiciona records no database do form –

objRecordset.Fields(“Subject”) = Request.Form(“txtSubject”)

objRecordset.Fields(“Message”) = Request.Form(“Message”)

objRecordset.Fields(“Day”) = Request.Form(“txtDay”)

objRecordset.Fields(“Month”) = Request.Form(“txtMonth”)

objRecordset.Fields(“Year”) = Request.Form(“txtYear”)

objRecordset.Fields(“AddedBy”) = Request.Form(“txtAddedBy”)

objRecordset.Fields(“DateAdded”) = Now()

objRecordset.Update

Updated = “True”

End If

If Request.Form(“btnDelete”) = “Delete” Then

‘–Delete o evento no database –

objRecordset.Delete adAffectCurrent

Response.Redirect(“calendar.asp”)

End If

%>

<html>

<center>

<%

If Updated = “True” Then

Response.Write(“<font size=4><b><font color=” & Chr(34) & “red” & Chr(34) & “>” & objRecordset.Fields(“Subject”) & “</font> has been updated</b></font><p>”)

End If

%>

<form method=”post” action=”edit_event.asp”>

<table border=”0″ cellpadding=”0″ cellspacing=”0″>

<tr>

<td>Dia:

<input type=”text” name=”txtDay” size=”4″ value=”<%= objRecordset.Fields(“Day”)%>”></td>

<td>Mês:

<input type=”text” name=”txtMonth” size=”10″ value=”<%= objRecordset.Fields(“Month”)%>”></td>

<td>Ano:

<input type=”text” name=”txtYear” size=”5″ value=”<%= objRecordset.Fields(“Year”)%>”></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”>Assunto:

<input type=”text” name=”txtSubject” size=”35″ value=”<%= objRecordset.Fields(“Subject”)%>”></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”><textarea name=”Message” cols=”40″ rows=”10″><%= objRecordset.Fields(“Message”)%></textarea></td>

</tr>

<tr>

<td colspan=”3″>&nbsp;</td>

</tr>

<tr>

<td colspan=”3″ align=”center”>Adicionado por:

<input type=”text” name=”txtAddedBy” size=”35″ value=”<%= objRecordset.Fields(“AddedBy”)%>”></td>

</tr>

</table>

<p>

<input type=”submit” name=”btnEdit” value=”Atualizar”>&nbsp;&nbsp;

<input type=”submit” name=”btnDelete” value=”Excluir”>&nbsp;&nbsp;

<input type=”Reset” name=”btnReset” value=”Limpar”>&nbsp;&nbsp;

<input type=”submit” name=”btnCalendar” value=”Voltar Calendario”>

</form>

</center>

</body>

</html>

<%

objRecordset.Close

Set objRecordset = Nothing

%>

Mesmo que seu site seja homologado muitas vezes por você mesmo, sempre passa alguma coisa que sua mente cansada não visualizou, ou simplesmente, deixou para resolver o tal erro, mais tarde e no final, não resolveu.
Use a cabeça, quer dizer, use mais mentes a seu favor. Fazer testes de estresses (que é forçar os erros acontecerem) no seu código ajuda a sanar os erros que restaram, mais não quer dizer que foram todos resolvidos.

Pessoas que nunca visualizaram seu site ou seu código podem ajudar nessa tarefa. Veja algumas coisas que nunca poderão acontecer em seu site:

1. Já imaginou um usuário entrar em um site, e clicar em um link que não vai para lugar nenhum? Complicado isso, é estressante! Para que tem a tal da “mãozinha” se não te leva a lugar algum?

2. Site que demora de carregar. Isso realmente mata. Você acha que é pouco tempo, mais para o usuário esperar mais de 10 segundos para seu site carregar, é uma eternidade. Otimize seu código, suas imagens, e o conteúdo do texto pode também ser otimizado. Pense nisso!

3. Tipografia! O que é isso? São as fontes usadas em seu site. Certo! Fontes? Não use tantas fontes em seu site, duas no máximo, para que ter um carnaval de fontes de vários tipos e de vários tamanhos? Foque na usabilidade.

4. Formulários. Essa palavra realmente desanima seu usuário. Nome, e-mail, telefone, celular, CPF, endereço, bairro, cidade, estado… Nossa! Quanta coisa! Você mesmo iria preencher isso tudo? Otimize esses campos. O usuário odeia digitar muito, somos preguiçosos na internet, não podemos gastar muito tempo.

Essas dicas podem te ajudar a ter um código mais limpo e ter uma boa usabilidade em seu site. Pesquise mais sobre usabilidade, as empresas hoje em dia procuram profissionais que tenham uma mente aberta para customizar sites antigos!

O Google sempre inova na área de SEO (otimização de sites) e no dia 1 de junho 2011 lançou no Brasil, esse serviço que serve de avaliação para os sites e funcionando como um indicador para o Google.
A ideia do botão não é bem diferente do botão curtir do Facebook, esse botão vai ser inserido no seu site,de forma bem parecida também com o “Curtir” e depois de instalado, os visitantes vão poder avaliar e recomendar a outros usuários, para adicionar o +1 ao site que esteja visitando, o usuário precisa estar conectado ao Google; quando estiver fazendo uma pesquisa no buscador, você vai encontrar o nome do site e ao lado o numero de vezes que foi adicionado o +1 ao site em questão; isso é muito importante para que os internautas possam encontrar conteúdo mais relevante a suas pesquisas; também é importante para os sites, pelo fato dessas avaliações servirem de atrativos para chamar novos visitantes e com isso aumentar seu tráfego.
Bom agora que foi explicado um pouco sobre este botão, vou estar ensinado como adicionar ele em seu site,o processo é bem simples e rápido, então vamos lá.

1° passo- Entre no site http://www.google.com/webmasters/+1/button

2° passo- depois escolha o idioma de sua preferencia e o tamanho que deseja visualizar o botão em seu site, são 4 opções: pequeno, médio, grande e padrão, ao lado já é possível visualizar sua escolha.

3° passo- mais abaixo você encontra a opções avançadas, basta clicar sobre o link que vai abrir as opções.

4° passo- Nessas opções que vai abrir você vai encontrar: Incluir contagem(marque esta opção),analisar(é onde você pode escolher entre Default(on load) e explicit), Função de retorno JS e URL para +1(onde você vai colocar o endereço do site em que deseja ser adicionado o botão.

5° passo- Abaixo você vai visualizar o código gerado pelo botão, onde você precisa copiar e colar nas paginas do site, ou seja adicionar esse JavaScript ao seu código fonte.
este código vai estar dividido em 2 partes; a 1° parte deve ser colocada na seção HEAD ou antes do fechamento de BODY, ja a 2°parte do código deve ser inserido onde você deseja exibir o botão.

Bom é isso amigos, o processo para adicionar o botão é bem simples, basta seguir as informações do site, é bem rápido e fácil de fazer, na própria pagina do plus one logo abaixo você pode esclarecer suas duvidas em perguntas frequentes.
Agora é só esperar que os visitantes avaliem seu site e se este botão do Google vai mesmo funcionar e agradar os internautas, só o tempo vai poder responder isso; nem tudo que o Google faz ou fez teve um bom retorno dos internautas, agora basta dar um tempo para o +1 plus one.

Agradeço a todos leitores do portal MXStudio e em breve vou estar escrevendo sobre como integrar o botão+1 com o Google Analytics; e antes de terminar você também pode clicar no botão aqui no portal e recomendar este artigo e os demais ao seus amigos é claro se você achar justo, abraço a todos e até breve.

Podemos por exemplo, mudar uma URL assim:

http://exemplo.com.br/teste/index.asp?titulo= titulo_pagina

Para:

http:// exemplo.com.br/ teste / titulo_pagina

Um Fórum pode ter uma URL que codifica as datas de cada entrada:

http://www.site.com.br/Forum/Posts.asp?Dia=11&Mes=04&Ano=2011
Ela pode ser alterada como esta:

http://www. site.com.br/Forum /11/04/2011/

que também permite ao usuário alterar a URL para ver todos os lançamentos disponíveis em abril, basta remover a codificação de texto no dia ’11 ‘, como se a navegação fosse “para cima” de um diretório:

http://www. site.com.br/Forum/04/2011/

Podemos também utilizar para proteção de hotlink, no seu arquivo httpd.ini adicione essas linhas:

# proteção hotlink
RewriteCond Host: (.+)
RewriteCond Referer: (?!http://1.*).*
RewriteRule .*.(?:gif|jpg|png) /block.gif [I,O]

Para esta expressão protegemos todos os formatos de arquivos com extensão gif, jpg e png. Você pode proteger outros formatos adicionando-os na última linha do código.

Instalando

Para a instalação necessitamos ter controle total de um servidor local ou próprio se a instalação for em um servidor compartilhado, utilize o painel de controle, geralmente por um botão de comando ativar/desativar, ou então por uma solicitação no helpdesk.

Criando regras para as urls amigáveis.

Vamos criar regras básicas, para facilitar o entendimento e absorção do material e neste caso, vamos criar uma regra para cada arquivo.
O site que vamos utilizar como exemplo para implementar as URL’s amigáveis tem as seguintes páginas:  home.asp, empresa.asp, produtos.asp, contato.asp

A pagina de home é uma pagina dinâmica, que recebe até 3 parâmetros: id do produto, categoria e quantidade (em caso de paginação). Ou seja, a pagina de noticias é acessada da seguinte maneira:

HTTP://www.site.com.br/home.asp?categoria=15&idproduto=23&quantidade=3

Logo, a regra deverá ser:

Esta é regra a conversão do link acima, que retornará o seguinte endereço:

HTTP://www.site.com.br/home/informatica/mouse-otico-15,23,3.html

Para as demais paginas, que não recebem parâmetros as regras ficarão mais simples, veja:

Modificando os links internos

Depois que as regras foram mapeadas e concluídas, e todas paginas já estão funcionando com a utilização do ISAPI REWRITE, chega a hora então e apontar os links internos do site para a novo formato do link. Vamos efetuar uma busca no site por todas as ocorrências da tag “<a>…</a>”. Localize e abra todos os arquivos que contenha a sintax “<a href=”.

Com os links já localizados, faça a modificação do código tomado como exemplo. Troque:

Por:

Para que o site permaneça funcionando, basta criar uma função que retorne o mesmo valor. Assim também é possível manter o site funcionando caso ocorre algum problema com o servidor ou com a própria aplicação.

Função para converter url amigável

Precisaremos então de uma função que converta os links atuais, para os novos formatos de links. Na sua biblioteca de funções cria as seguinte funções:

Abaixo alguns metacaracteres, com o seu significado entre parêntesis a seguir:

• . (qualquer caractere)
• * (zero ou mais precedentes)
• + (uma ou mais precedentes)
• {} (mínimo ao máximo quantificador)
• ? (modificador ungreedy)
• ! (no início da string significa “padrão negativo “)
• ^ (início da seqüência de caracteres, ou “negativo” se no início de uma série)
• $ (final da string)
• [] (corresponde a nenhum conteúdo)
• - (intervalo se usado entre colchetes)
• () (grupo, de volta referenciado)
• | (alternativa, ou)
• \ (o próprio caractere de escape)

Usando expressões regulares, é possível pesquisar por todos os tipos de padrões de URLs e reescrevê-los quando eles coincidem. Hora para um outro exemplo – que queríamos antes de ser capaz de identificar essa URL e reescrevê-lo:

http://www.site.com.br/ araras/brasil-azul/

Vamos fazer o servidor interpretar isso como o seguinte, mas para todos os produtos:

http://www. site.com.br /produto_por_nome.asp?produto_nome= brasil-azul

E podemos fazer isso de forma relativamente simples, com a seguinte regra:

RewriteRule ^ araras/([A-Za-z0-9-]+)/?$      produto_por_nome.asp?produto_nome =$1                  [NC,L]               # Processo araras

Com essa regra, qualquer URL que começa com ” araras “, seguido por uma barra (araras /), então um ou mais (+) em qualquer combinação de letras, números e hífens ([A-Za-z0-9]) ( Observe o hífen no final da seleção de caracteres entre colchetes – que deve ser adicionado lá para ser tratado, literalmente, ao invés de como um separador de intervalo),nome do produto de referência entre parênteses, com $1 na substituição.

Podemos fazer ainda mais genérica, se queremos, de modo que não importa o diretório de um produto, assim:

RewriteRule ^ [A-Za-z-]+/([ produto_por_nome.asp A-Za-z0-9-]+)/?$           ? produto_nome = $ 1               [NC, L]                 # Processa todos os produtos

Como você pode ver, temos substituído ” araras” com um padrão que combina letras e hífens. Essa regra será para diretório araras ou qualquer outro diretório cujo nome é composto de pelo menos uma ou mais letras e hífens.

Flags

Flags são adicionados ao final de uma regra como interpretar e lidar com a regra. Elas podem ser usadas para tratar a regra como case-sensitive, para parar regras de processamento, e os one matches atual, ou uma variedade de outras opções. Eles são separados por vírgula, e entre colchetes. Aqui está uma lista das Flags, com seus significados (esta informação é incluído no cheat sheet).

• C (acorrentado com a regra seguinte)
• CO=cookie (set cookie especificado)
• E=var:value (var conjunto variável de ambiente para o valor)
• F (forbidden [proibido] – envia um cabeçalho de 403 para o usuário)
• G (gone [se foi] – não existe mais)
• H=handler (conjunto manipulador)
• L (last – deixar de regras de processamento)
• N (next – continua regras de processamento)
• NC (case insensitive)
• NE (n ão escapar caracteres especiais na URL de saída)
• NS (ignorar esta regra se o pedido é um SUBPEDIDO)
• P (proxy – ou seja, o Apache deve pegar o conteúdo remoto especificado na seção de substituição e devolvê-lo)
• PT (passar – use quando URLs com os manipuladores de processamento adicional, por exemplo, mod_alias)
• R (temporária redirecionar para nova URL)
• R=301 (redirecionamento permanente para nova URL)
• QSA (query string de pedido de URL substituído)
• S=x (ignorar as regras ao lado x)
• T=mime-type (força especificada tipo mime)

Exceções e casos especiais

As condições podem ser testadas em algumas maneiras diferentes ,elas não precisam ser tratadas como padrões de expressões regulares, embora esta seja a maneira mais comum de serem usadas. Aqui estão as várias maneiras reescrever conditons pode ser processado:

•Pattern (seqüência de teste é maior do padrão)
• =Pattern (seqüência de teste é igual ao padrão)
• -d (seqüência de teste é um diretório válido)
• -f (seqüência de teste é um arquivo válido)
• -s (seqüência de teste é um arquivo válido com tamanho maior que zer)
• -l (eqüência de teste é um link simbólico)
• -F (seqüência de teste é um arquivo válido e acessível (via SUBPEDIDO))
• -U (seqüência de teste é uma URL válida, e acessíveis (via SUBPEDIDO))

Variáveis de Servidor

Variáveis do servidor são uma seleção de itens que você pode testar quando estiver a escrever reescrever condições. Isto permite-lhe aplicar as regras com base em todos os tipos de parâmetros da requisição, incluindo os identificadores navegador, URL de referência ou uma infinidade de outras seqüências. As variáveis são do seguinte formato:
% {variable_name}

• HTTP Headers
o HTTP_USER_AGENT
o HTTP_REFERER
o HTTP_COOKIE
o HTTP_FORWARDED
o HTTP_HOST
o HTTP_PROXY_CONNECTION
o HTTP_ACCEPT
• Variáveis Connection
o REMOTE_ADDR
o REMOTE_HOST
o REMOTE_USER
o REMOTE_IDENT
o REQUEST_METHOD
o SCRIPT_FILENAME
o PATH_INFO
o QUERY_STRING
o AUTH_TYPE
• Server Variables
o DOCUMENT_ROOT
o SERVER_ADMIN
o SERVER_NAME
o SERVER_ADDR
o SERVER_PORT
o SERVER_PROTOCOL
o SERVER_SOFTWARE
• Data e Hora
o TIME_YEAR
o TIME_MON
o TIME_DAY
o TIME_HOUR
o TIME_MIN
o TIME_SEC
o TIME_WDAY
o TIME
• Itens Especiais
o API_VERSION
o THE_REQUEST
o REQUEST_URI
o REQUEST_FILENAME
o IS_SUBREQ

Exemplo de regras

Para redirecionar um domínio antigo para um novo domínio:

RewriteCond %{HTTP_HOST} velho_dominio\.com [NC] RewriteRule ^(.*)$ http://www.novo_dominio.com /$1 [L,R=301]

Para redirecionar todas as solicitações faltando “www” (sim www):

RewriteCond %{HTTP_HOST} ^dominio\.com [NC] RewriteRule ^(.*)$ http://www.dominio.com/$1 [L,R=301]

Para redirecionar todas as solicitações com “www” (sem www):

RewriteCond %{HTTP_HOST} ^www\.dominio\.com [NC] RewriteRule ^(.*)$ http:// dominio.com/$1 [L,R=301]

Redirecionar página antiga para a nova página:

RewriteRule ^old-url\.htm$ http://www.dominio.com/nova-url.htm [NC,R=301,L]

[size="1"][font="Garamond"]
Fonte: vários sites e URL´s citadas no próprio post.[/font][/size]Abaixo alguns metacaracteres, com o seu significado entre parêntesis a seguir:

• . (qualquer caractere)
• * (zero ou mais precedentes)
• + (uma ou mais precedentes)
• {} (mínimo ao máximo quantificador)
• ? (modificador ungreedy)
• ! (no início da string significa “padrão negativo “)
• ^ (início da seqüência de caracteres, ou “negativo” se no início de uma série)
• $ (final da string)
• [] (corresponde a nenhum conteúdo)
• - (intervalo se usado entre colchetes)
• () (grupo, de volta referenciado)
• | (alternativa, ou)
• \ (o próprio caractere de escape)

Usando expressões regulares, é possível pesquisar por todos os tipos de padrões de URLs e reescrevê-los quando eles coincidem. Hora para um outro exemplo – que queríamos antes de ser capaz de identificar essa URL e reescrevê-lo:

http://www.site.com.br/ araras/brasil-azul/

Vamos fazer o servidor interpretar isso como o seguinte, mas para todos os produtos:

http://www. site.com.br /produto_por_nome.asp?produto_nome= brasil-azul

E podemos fazer isso de forma relativamente simples, com a seguinte regra:

RewriteRule ^ araras/([A-Za-z0-9-]+)/?$
produto_por_nome.asp?produto_nome =$1 [NC,L] # Processo araras

Com essa regra, qualquer URL que começa com ” araras “, seguido por uma barra (araras /), então um ou mais (+) em qualquer combinação de letras, números e hífens ([A-Za-z0-9]) ( Observe o hífen no final da seleção de caracteres entre colchetes – que deve ser adicionado lá para ser tratado, literalmente, ao invés de como um separador de intervalo),nome do produto de referência entre parênteses, com $1 na substituição.

Ppodemos fazer ainda mais genérica, se queremos, de modo que não importa o diretório de um produto, assim:

RewriteRule ^ [A-Za-z-]+/([ produto_por_nome.asp A-Za-z0-9-]+)/?$? produto_nome = $ 1 [NC, L] # Processa todos os produtos

Como você pode ver, temos substituído ” araras” com um padrão que combina letras e hífens. Essa regra será para diretório araras ou qualquer outro diretório cujo nome é composto de pelo menos uma ou mais letras e hífens.

Flags

Flags são adicionados ao final de uma regra como interpretar e lidar com a regra. Elas podem ser usadas para tratar a regra como case-sensitive, para parar regras de processamento, e os one matches atual, ou uma variedade de outras opções. Eles são separados por vírgula, e entre colchetes. Aqui está uma lista das Flags, com seus significados (esta informação é incluído no cheat sheet).

• C (acorrentado com a regra seguinte)
• CO=cookie (set cookie especificado)
• E=var:value (var conjunto variável de ambiente para o valor)
• F (forbidden [proibido] – envia um cabeçalho de 403 para o usuário)
• G (gone [se foi] – não existe mais)
• H=handler (conjunto manipulador)
• L (last – deixar de regras de processamento)
• N (next – continua regras de processamento)
• NC (case insensitive)
• NE (n ão escapar caracteres especiais na URL de saída)
• NS (ignorar esta regra se o pedido é um SUBPEDIDO)
• P (proxy – ou seja, o Apache deve pegar o conteúdo remoto especificado na seção de substituição e devolvê-lo)
• PT (passar – use quando URLs com os manipuladores de processamento adicional, por exemplo, mod_alias)
• R (temporária redirecionar para nova URL)
• R=301 (redirecionamento permanente para nova URL)
• QSA (query string de pedido de URL substituído)
• S=x (ignorar as regras ao lado x)
• T=mime-type (força especificada tipo mime)

Exceções e casos especiais

As condições podem ser testadas em algumas maneiras diferentes ,elas não precisam ser tratadas como padrões de expressões regulares, embora esta seja a maneira mais comum de serem usadas. Aqui estão as várias maneiras reescrever conditons pode ser processado:

•
Pattern (seqüência de teste é maior do padrão)
• =Pattern (seqüência de teste é igual ao padrão)
• -d (seqüência de teste é um diretório válido)
• -f (seqüência de teste é um arquivo válido)
• -s (seqüência de teste é um arquivo válido com tamanho maior que zer)
• -l (eqüência de teste é um link simbólico)
• -F (seqüência de teste é um arquivo válido e acessível (via SUBPEDIDO))
• -U (seqüência de teste é uma URL válida, e acessíveis (via SUBPEDIDO))

Variáveis de Servidor

Variáveis do servidor são uma seleção de itens que você pode testar quando estiver a escrever reescrever condições. Isto permite-lhe aplicar as regras com base em todos os tipos de parâmetros da requisição, incluindo os identificadores navegador, URL de referência ou uma infinidade de outras seqüências. As variáveis são do seguinte formato:
% {variable_name}

• HTTP Headers
o HTTP_USER_AGENT
o HTTP_REFERER
o HTTP_COOKIE
o HTTP_FORWARDED
o HTTP_HOST
o HTTP_PROXY_CONNECTION
o HTTP_ACCEPT
• Variáveis Connection
o REMOTE_ADDR
o REMOTE_HOST
o REMOTE_USER
o REMOTE_IDENT
o REQUEST_METHOD
o SCRIPT_FILENAME
o PATH_INFO
o QUERY_STRING
o AUTH_TYPE
• Server Variables
o DOCUMENT_ROOT
o SERVER_ADMIN
o SERVER_NAME
o SERVER_ADDR
o SERVER_PORT
o SERVER_PROTOCOL
o SERVER_SOFTWARE
• Data e Hora
o TIME_YEAR
o TIME_MON
o TIME_DAY
o TIME_HOUR
o TIME_MIN
o TIME_SEC
o TIME_WDAY
o TIME
• Itens Especiais
o API_VERSION
o THE_REQUEST
o REQUEST_URI
o REQUEST_FILENAME
o IS_SUBREQ

Exemplo de regras

Para redirecionar um domínio antigo para um novo domínio:

RewriteCond %{HTTP_HOST} velho_dominio\.com [NC] RewriteRule ^(.*)$ http://www.novo_dominio.com /$1 [L,R=301]

Para redirecionar todas as solicitações faltando “www” (sim www):

RewriteCond %{HTTP_HOST} ^dominio\.com [NC] RewriteRule ^(.*)$ http://www.dominio.com/$1 [L,R=301]

Para redirecionar todas as solicitações com “www” (sem www):

RewriteCond %{HTTP_HOST} ^www\.dominio\.com [NC] RewriteRule ^(.*)$ http:// dominio.com/$1 [L,R=301]

Redirecionar página antiga para a nova página:

RewriteRule ^old-url\.htm$ http://www.dominio.com/nova-url.htm [NC,R=301,L]

Para ter os usuários do site assim www.meusite.com.br/usuario, sem o default.asp?usr=NOME, só pelo /usuário:

RewriteEngine on
# Internamente adicionar extensões ao pedido
RewriteCond %{REQUEST_FILENAME}.asp -f
RewriteRule (.*) $1.asp

Fonte: vários sites e URL´s citadas no próprio post.

Como instalar o Google Analytics :
1° passo você precisa criar uma conta gratuita no google analytics, se você ja possui uma conta no Google será necessário apenas entra com seu login e senha na pagina do Google analytics e aceitar os termos de contrato que você vai ser direcionado ao site.

2° passo informe seus dados ao site e coloque seu domínio o qual o Google deverá analisar .

3° após informar o domínio a ser analisado, você precisa gerar o código que será colocado nas paginas do seu site , salve em um arquivo de texto.

4° para finalizar a instalação, depois de gerado o código você vai inserir ele dentro de todas as paginas do site antes do fechamento da tag BODY , para essa instalação será necessário que você ou seu webmaster edite o códigos das paginas do site. Se o seu site não possui um CMS(gerenciador de conteúdo) será necessário utilizar o bom e velho Dreamweaver .
abra seu site no Dreamweaver vá até o código e coloque antes do fechamento da tag body sem mecher no restante do código, depois só salvar e enviar ao servidor, após inserir esse código em todas as paginas.

5° no Google analytics vai aparecer que já é possível analisar seu site, porem só após 24h vai aparecer suas visitas e relatórios sobre o site.

Bom é isso pessoal, uma ferramenta necessária ao mundo moderno que vai facilitar sua vida com seus clientes ter esse feedback e saber qual o retorno que seu site esta tendo, um aplicativo da marca Google, qualidade garantida e o melhor gratuito.
até mais pessoal, com mais artigos e tutoriais aqui no portal mxstudio, se você esta afim de conferir mais artigos entre no meu site www.brunohenris.com muito obrigado.

A sintaxe a utilizar getSize é a seguinte:

someBoolean = pegatamanho(URL, width, height, depth, flType)
‘URL, largura, altura, profundidade, flType

• someBoolean será definido com base verdadeiro ou falso se o script foi capaz de determinar os atributos de imagens
• URL é uma entrada informando a URL da imagem, tais como http://www.sintchospir.com/images/sua_imagem.jpg
• largura será definida para a largura da imagem, ou -1 para script failed
• A altura será definido para a altura da imagem, ou -1 para script failed
•Profundidade será definido como a profundidade da imagem, ou -1 para script failed
• FlType será definido o tipo de arquivo de imagem foi, GIF ou JPG

Utilizando as funções de string binária como midb e lenb. Uma vez que todas as imagens são arquivos binários, essas funções são necessárias.

0 then 'começar em bytes não no início
strbuff = midb(objHTTP.responseBody, offset, bytes)
end if
if bytes = -1 then ' Get All!
GetBytes = objHTTP.responseBody 'ReadAll
else
GetBytes = midb(objHTTP.responseBody, 1, bytes)
end if
end function

set obj = Nothing
end function
%>

Antes de utilizar um array devemos declara-lo de maneira obrigatória, para isso utilizamos a palavra chave DIM, deste modo.

dim Array(50)

Despois da palavra DIM devemos indicar o nome do array e a seguir, entre parênteses, coloca-se o número de posição máxima do array, neste caso 50.

Os arrays começam desde a posição 0, ou seja, o primeiro elemento de um array está na posição 0. Portanto, se o array foi definido com 50 campos, como no exemplo, terá 51 elementos, primeira posição será a 0 e a última posição seria a 50.

Para atribuir um valor a um array se realiza igual que uma variável, porém acessando com o índice da posição que queremos escrever.

Array(0) = 128

Para utilizar o conteúdo de um array devemos faze-lo indicando o índice ao que se deseja acessar. Por exemplo, se quiséssemos imprimir na página a primeira posição de nosso Array o faríamos desta maneira.

document.write(Array(0))

Agora vamos ver um exemplo sobre como utilizar os arrays, onde vamos realizar dois percorridos, um para escrever nele e o outro para ler a informação e escreve-la na página.
dim matriz (10)
for i=0 to 10
matriz(i)=100 * i
next
for i=0 to 10
document.writeln(“Posicao ” & i & “: ” & matriz(i) & “
“)
next

Este exemplo escreveria na página as posições do array, que contém variáveis numéricas que correspondem de multiplicar seu índice por 100.
Bom agora, que vimos como funciona os arrays iremos partir para Arrays dinâmicos.

Aplicação de Objetos com Arrays Dinâmicos

Dentro de qualquer aplicação que eventualmente é necessário o uso de matrizes de dados. Nós precisamos encontrar os dados para o objetos, a fim de simplificar a lógica que vai ser de execução, bem como para tornar o código mais flexível e escalável. Usando uma classe que engloba uma série de objetos, que se mantém e matriz de objetos, descobrimos que a classe superior nos permite adquirir uma forma simplificada de classificar, filtrar e controlar os itens de dados, bem como os valores desses itens de dados.

Essas classes simplificada permitirá que alcance rapidamente e aprender a usar um array dinâmico que mantém uma matriz dinâmica de objetos (ambas as matrizes dinâmicas objetos que estão sendo eles mesmos).

A camada mais profunda da nossa estrutura é uma classe simples de todos os atributos que você pode precisar de realizar.

‘*********** class ***************
‘Classe valor do item
Class item_value_class
Private c_item_value
‘ handle value (let/get)
public property let value(byval data)
c_item_value = data
end property
public property get value()
value = c_item_value
end property
end class
‘******************************************

Observe que esta classe tem um atributo com duas propriedades para permitir a escrita e leitura para o atributo. Isto é normal e não é nada especial. Passamos agora para a próxima camada, onde encontramos a nossa primeira matriz dinâmica.

‘********* classe média ***********************
Class item_class
Private c_item
Private c_values() ‘ Matriz de todos os valores para o item
Private c_size ‘ max determina os valores possíveis para o item

‘ handle item (let/get)
public property let item(byval data)
c_item = data
end property
public property get item()
item = c_item
end property

‘*************************************************
‘************* metodos ***************************
‘*************************************************

‘*********** Event Handlers *************
Private Sub Class_Initialize()
Redim c_values(0)
Set c_values(0) = New item_value_class
c_size=0
End Sub
‘ matar todos os objetos em Adata e livrar memória
Private Sub Class_Terminate()
Dim x
for x=0 to ubound(c_values)
Set c_values(0) = nothing
next
c_size=0
erase c_values
End Sub
‘****************************************
Public Function getValue(iPos)
getValue = c_values(iPos).value
End Function

Public Function putValue(iPos,data)
if iPos>c_size then
Redim preserve c_values(iPos)
for x = c_size+1 to ubound(c_values)
set c_values(x)= New item_value_class
next
c_size=iPos
end if
c_values(iPos).value=cstr(data)

End Function

Public Property get numbervalues()
numbervalues=c_size
end property

Public property get allvalues()
allvalues=c_values
end property

Public property let allvalues(ByRef temp)
Dim x
Dim sizetochange
sizetochange=ubound(temp)
if sizetochange < c_size then
for x=sizetochange+1 to ubound(c_values)
set c_values(x)=nothing
next
Redim preserve c_values(sizetochange)
else
Redim preserve c_values(sizetochange)
for x = c_size+1 to ubound(c_values)
set c_values(x)= New item_value_class
next
end if
c_size=sizetochange
for x=0 to sizetochange
c_values(x).value = temp(x).value
next
end property
end class
'******************************************

Vemos a instanciação de uma matriz de objetos de valor a nossa classe. Observe sempre que adicionar um valor com o método putValue nossa matriz é automaticamente aumentado e instanciado. Há uma propriedade especial chamada de "allvalues" que cria um ponto de referência para a matriz que esta classe possui. Para todos os valores do GET propriedade retorna a referência para a matriz, enquanto o imóvel locado nos permite definir um outro array de objetos da nossa classe de valor igual a outro. As propriedades allvalues tornam-se importantes em nossa camada superior chamada de Dynamic_Object_Array_Class ".

'******** classe superior *********************
Class Dynamic_Object_Array_Class
'************** Properties **************
Private aData()
Private c_size
'****************************************

'*********** Event Handlers *************
Private Sub Class_Initialize()
Redim aData(0)
Set aData(0) = New item_class
c_size=0
c_numberlinks=1
End Sub
' matar todos os objetos em Adata e livrar memória
Private Sub Class_Terminate()
Dim x
for x=0 to ubound(aData)
Set aData(0) = nothing
next
c_size=0
erase aData
End Sub
'****************************************
Public Property Get allitems()
allitems = aData
end property

Public Property Get getsize()
getsize = c_size
end property

Public Function push()
c_size = c_size+1
Redim preserve aData(c_size)
set aData(c_size)= New item_class
push=c_size
End Function

Public Function pop(ipos)
Dim tempcount
pop=aData(ipos).item
if ipos < c_size then
for tempcount=ipos to (c_size – 1)
aData(tempcount).item = aData(tempcount+1).item
aData(tempcount).allvalues = aData(tempcount+1).allvalues
next
end if
set aData(c_size)= nothing
c_size = c_size-1
Redim preserve aData(c_size)
End Function’
End Class
'********** classe superior final ***************

A classe superior implementa um push-pop e um método para aumentar automaticamente ou diminuir o array de objetos da nossa classe de item que a classe superior detém. Observe que o método de classe anteriores allvalues é implementada no método pop na nossa class = mais alto. Agora que temos a nossa matriz dinâmica, devemos colocá-lo para uso. A maneira mais fácil de ver como ele funciona é a de armazenar alguns dados na matriz e em seguida, exibi-la novamente.

'******** Exemplo de código usando Array Dinâmico *****

<%
for y=0 to my_array.getsize
Response.Write "

”
for x=0 to my_array.allitems()(y).numbervalues
if my_array.allitems()(y).getValue(x)”" then
Response.Write “

”
end if
next
next
%>

‘********************************************

Depois de executar o nosso código de exemplo, devemos ver o seguinte em nosso navegador da Web:

‘******* Exemplo de Output *********************

Item: Olá
Item: TRUE FALSE
Value: yes
Value: no
Item: Seu Nome
Item: Outro Item
Item: Lugar em Concurso
Value: Terceiro
Value: segundo
Value: Primeiro
Item: Escolha o Hotel
Value: Nacional Inn
Value: Ibis

‘********* end example output ****************

Resumo

Arrays dinâmicos de objetos que contêm matrizes dinâmicas dos objetos nos permitem criar a estrutura que precisamos de uma forma simplificada e reutilizáveis. Nossas matrizes também serão auxiliadas na classificação, filtragem e manipulação de dados. Apesar de eu não ter incluído o código de exemplo para a classificação e filtragem, uma vez que você entender como funcionam as classes, gerando a classificação e os métodos de filtragem é bastante fácil.
Podemos ainda, Redimensionar arrays
Este tipo de arrays redimensionais se chama array dinâmico. Para criar este tipo de arrays podemos utilizar a sentença dim (como criávamos os anteriores) ou a sentença redim, com a particularidade que não lhe colocamos nenhum valor entre parênteses onde antes indicávamos o número de campos do array.

dim meu_array()
redim meu_outro_array()

Quando usamos arrays dinâmicos podemos utilizar a sentença redim para indicar o número de dimensões e a quantidade de campos de cada dimensão.

Com esta sentença estamos indicando que meu_array deve ter o tamanho 10. Campos desde 0 até a 10.

redim meu_array(10)

Se indicamos a chave “preserve” estamos garantindo que o conteúdo dos campos que havia previamente no array se mantém.

redim preserve meu_array(20)

Por último, se em qualquer momento reduzimos o número de campos perderemos o que possa ter sido salvo nos campos que se eliminaram.

No seguinte exemplo criamos um array dinâmico e o redimensionamos inicialmente a tamanho 3. Preenchemos e mostramos seus distintos valores. Posteriormente o redimensionamos outra vez para que chegue até a posição 7, salvando os valores antigos. Para acabar preenchendo os campos que criamos novos e mostramos todos os valores do array.

dim frutas()
redim frutas(3)

frutas(0) = “Pêra”
frutas(1) = “Uva”
frutas(2) = “Maçã”
frutas(3) = “Melão”

for each fruta in frutas
document.write fruta & “
”
next

redim preserve frutas(7)

frutas(4) = “Melancia”
frutas(5) = “Laranja”
frutas(6) = “Banana”
frutas(7) = “Tangerina”

for each fruta in frutas
document.write fruta & “
”
next

Para saber o número de campos de um array

Um dos dados típicos que necessitamos extrair de um array é seu número de posições, útil, por exemplo, para fazer um percorrido a um array, desde a primeira até o último campo. Para isso, utilizamos a função uBound() de VBScript. A função UBound permite descobrir o que o membro da matriz superior é definida. Isto torna mais fácil o loop para percorrer um array do início ao fim.

Digamos que você usa a função split para analisar uma string em um array. Então você:
Dim ListaArray

SentStr = ” Oitenta e sete anos atrás nossos pais trouxeram ”
ListaArray = split(SentStr, ” “)

Agora você tem uma matriz listarray que pretende percorrer, mas você não sabe até onde ir. Como saber quando você tiver chegado ao final do array ?

A resposta é a função UBound. ubound dá-lhe o membro superior matriz de uma matriz. Neste caso, a matriz tem 10 palavras na mesma. O arrays começam sempre a numeração em zero, significa que essa matriz pontos de 0 a 9 são tomadas. Se você fizer
ubound(ListArray)

O resultado é 9.

Você pode então fazer um loop através dos membros, que operam em cada um .

for loopctr = 0 to ubound(ListaArray)
response.write ListaArray(loopctr)
next

Outro Exemplo:

dim paises (4)
response.write ubound (paises)
Escreveria na página o número do campo mais alto do array paises, neste caso 4.
Ademais, se por acaso algum dia necessitamos, também temos a nossa disposição a função lBound(), que devolve o número da posição com índice menor do array.
response.write lbound (paises)

A última linha sobre nosso array de paises definido anteriormente escreveria um 0 na página web, visto que o array começa na posição zero.

Arrays multidimensionais

Podem-se construir matrizes multidimensionais, ou seja, que nos permitam criar matrizes de várias coordenadas. Para trabalhar com eles utiliza-se uma vírgula que separa os dois índices. Por exemplo, podemos definir uma matriz de 10×10 desta maneira.

dim Array2Dimensoes (9,9)

Como o array é de 10 campos, utilizamos um 9 e suas posições serão as 10 que vão desde o 0 ao 9. Para escrever e ler do Array podemos utilizar a vírgula de maneira similar a como se declara. Por exemplo, para colocar dados na posição 0,4 faríamos o seguinte:

Array2Dimensoes (0,4) = “texto posicao 0,4″

Abaixo, temo um exemplo de como armazenar o conteúdo do vetor em uma session, muito usada pelo pessoal de e-commerce para carrinhos de compras.

<%
"A função abaixo é generica e pode ser utilizada como um arquivo include
Function VetorMonta(Acao,Valor)
"Usamos o case para manipular a ação da função
Select Case Trim(Acao)
"Inclui nova posicao ao vetor
Case "Incluir"
"Guarda na variavel Vetor o conteudo da Session
Vetor = Session("GuardaVetor")
"Verifica se a Variavel Vetor é um Array, caso nao for entao definimos ela um Array
If Not IsArray(Vetor) Then Vetor = Array() End if
"Verifica se o Valor que esta sendo inserido já esta no Vetor se estiver entao nao inseri para nao haver duplicidades do vetor
If InStr(Join(Vetor), Valor) = 0 Then
"Este comando ira preservar o vetor e adciona + 1 valor
ReDim preserve Vetor(UBound(Vetor)+1)
"Este é o valor que estamos adicionando no vetor
Vetor(Ubound(Vetor )) = Valor
"Coloca o conteudo da variavel vetor dentro da Session
Session("GuardaVetor") = Vetor
End if
"Apaga uma determinada posicao do vetor
Case "Excluir"
"Inicia a varivel vetor como vazia
Vetor = Array()
"Criamos uma nova variavel Auxiliar e guardamos o valor da Session
AuxVetor = Session("GuardaVetor")
"Definine a Session como um Array vazio
Session("GuardaVetor") = Array()
"Faz um laço em todas as posições do vetor
For i = 0 To Ubound(AuxVetor)
"Verifica se o valor passado para excluir do vetor é diferente do valor que esta dentro da variavel Auxiliar
If AuxVetor(i) (Valor) Then
“Este comando ira preservar o vetor e adciona + 1 valor
ReDim preserve Vetor (UBound(Vetor)+1)
“Este é o valor que estamos adicionando no vetor
Vetor (Ubound(Vetor)) = AuxVetor(i)
“Coloca o conteudo da variavel vetor dentro da Session
Session(“GuardaVetor”) = Vetor
End If
Next
“Fim do Case
End Select
End Function
Function Incluir_Vetor
“Executa a função que ira criar uma posição do vetor, basta passar a acao e o valor
Call VetorMonta(“Incluir”,Replace(Request(“Valor_Vetor”),”"”,”"))
End Function
Function Excluir_Vetor(Valor_Vetor)
“Executa a função que ira deletar uma posição do vetor, basra passar a acao e o valor
Call VetorMonta(“Excluir”,Valor_Vetor)
End Function
Function VisualizaValoresVetor
“Veriofica se a Session é um array, caso nao for então atribuimos a Session como um Array
IF Not IsArray(session(“GuardaVetor”)) Then session(“GuardaVetor”) = Array() End if
“Faremos um laço entre todos os vetores criados
For x = 0 To ubound(session(“GuardaVetor”)) “ira fazer um laço mostrando todos os vetores criados
“Mostra os valores armazenados na Session e adiciona um link para apagar a posição do vetor caso queira
Response.Write session(“GuardaVetor”)(x) & “(Apagar)” & “
”
Next
“Verifica se a Session tem alguma posição, se tiver mostra a opção de apagar todos os vetores
If ubound(session(“GuardaVetor”)) >= 0 Then
Response.Write “
” &”Apagar Tudo” & “
” “Imprime o Vetor na tela
End if
End Function
Function LimpaVetor
“Limpa todas as posiçoes do vetor, apagando a Session
session(“GuardaVetor”) = Empty
End Function
“USAMOS CASES PARA MANUPULARAS CHAMADAS DAS FUNÇÕES
useraction=request(“action”)
select case useraction
Case “Incluir_Vetor”
“Chama a function que ira incluir um valor para o vetor
Call Incluir_Vetor
Case “Excluir_Vetor”
“Chama a function que ira excluir um valor para o vetor
Call Excluir_Vetor(Request(“Valor_Vetor”))
Case “LimpaVetor”
“Chama a function que apagar todas as posições do vetor
Call LimpaVetor
End Select
%>

Ainda dentro do diretório /fckeditor/, apague todos os arquivos de outra linguagem de programação, (PHP, CFM, LASSO, PL, PY) mantenha apenas os XML, HTML , JS e ASP.

Os arquivos principais que utilizaremos serão fckconfig.js e fckeditor.asp.
fckconfig.js

FCKConfig.ToolbarSets["Default"] = [
['Source','DocProps','-','Save','NewPage','Preview','-','Templates'],
['Cut','Copy','Paste','PasteText','PasteWord','-','Print','SpellCheck'],
['Undo','Redo','-','Find','Replace','-','SelectAll','RemoveFormat'],
['Form','Checkbox','Radio','TextField','Textarea','Select','Button','ImageButton','HiddenField'],
‘/’,
['Bold','Italic','Underline','StrikeThrough','-','Subscript','Superscript'],
['OrderedList','UnorderedList','-','Outdent','Indent','Blockquote','CreateDiv'],
['JustifyLeft','JustifyCenter','JustifyRight','JustifyFull'],
['Link','Unlink','Anchor'],
['Image','Flash','Table','Rule','Smiley','SpecialChar','PageBreak'],
‘/’,
['Style','FontFormat','FontName','FontSize'],
['TextColor','BGColor'],
['FitWindow','ShowBlocks','-','About'] // No comma for the last row.
] ;

FCKConfig.ToolbarSets["Basic"] = [
['Bold','Italic','-','OrderedList','UnorderedList','-','Link','Unlink','-','About']
] ;

ckeditor.asp

Definimos o trecho abaixo de código com estes novos dados. Aqui é definido o diretório base, tamanho da área do editor e também o tipo de barra formada, podendo variar entre Default ou Basic mostrado anteriormente no arquivo fckconfig.js.

Private Sub Class_Initialize()
sBasePath = “/fckeditor/”
sWidth = “100%” ‘Aqui é a largura, aconselho a manter 1005
sHeight = “400″ ‘Aqui é altura
sToolbarSet = “Default”
sValue

Na segunda alteração do arquivo fckeditor.asp iremos mudar para o caminho fckeditor/editor/
Public Function CreateHtml( instanceName )
dim html

If IsCompatible() Then

Dim sFile, sLink
If Request.QueryString( “fcksource” ) = “true” Then
sFile = “fckeditor.original.html”
Else
sFile = “fckeditor.html”
End If

sLink = sBasePath & “fckeditor/editor/” & sFile & “?InstanceName=” + instanceName

If (sToolbarSet & “”) “” Then
sLink = sLink + “&Toolbar=” & sToolbarSet
End If

Iremos agora fazer a chamada deste arquivo fckeditor.asp em uma página asp com formulário simples.

Na página onde você quer que apareça o editor, exatamente no local, coloque o seguinte código, iremos utilizar um include chamando o arquivo fckeditor.asp. Esta página também precisa estar dentro do diretório /fckeditor/

Os caracteres especiais, palavras acentuadas e outros use a metatag:

A acentuação, pode ser resolvida, apenas mudando no inicio das páginas de alteração e inserção de dados no banco de dados, faça as seguintes mudanças:

altera para:

Recuperando os dados dentro do editor. iremos utilizar um include chamando o arquivo fckeditor.asp.

Vamos mudar o FCK Editor 2.6.4 , que vem habilitado para PHP por padrão, para nossa linguagem ASP, entre no arquivo fckconfig.js, dentro do diretório /fckeditor/ e altere as linhas:
var _FileBrowserLanguage = ‘asp’; // asp | aspx | cfm | lasso | perl | php | py
var _QuickUploadLanguage = ‘asp’; // asp | aspx | cfm | lasso | perl | php | py

Você pode mudar o visual (skin) do editor, iremos usar a do office 2003, para isso iremos alterar no arquivo fckconfig.js, dentro do diretório /fckeditor/ a seguinte linha:
FCKConfig.SkinPath = FCKConfig.BasePath + ‘skins/office2003/’;

você indica o caminho da skin que você quer que apareça, é só copiar e subistituir, é só escolher um dos tres:

FCKConfig.SkinPath = FCKConfig.BasePath + ‘skins/default/’ ;
FCKConfig.SkinPath = FCKConfig.BasePath + ‘skins/office2003/’ ;
FCKConfig.SkinPath = FCKConfig.BasePath + ‘skins/silver/’ ;

você pode baixar mais skins acessando aqui: http://www.midiaville.com.br/docs/arquivos/skins/index.php
Você também pode mudar o visual do meu editor, alterando os ícones da barra. Apenas no arquivo fckconfig.js, onde citamos acima. Mudando o parâmetro ToolbarSets

Para fazer upload de fotos, banner flash, arquivos para links e etc.

Navegue até o diretório: /fckeditor/editor/ filemanager/ connectors/
Apague tudo que tiver lá dentro, deixe só o diretório /asp/ dentro dele, edite o arquivo config.asp

Na linha

ConfigIsEnabled = False ‘mude de False para true, isso habilita o upload
ConfigUserFilesPath = “/userfiles/”

Coloque no lugar de userfiles o nome do seu diretório onde será feito o upload a barra no inicio quer dizer que este diretório está na raiz do site. Caso o diretório que você listou aqui não exista o fckeditor vai cria-lo.
Algumas soluções para alguns erros apresentados pelo Editor.
Dentro do diretório FCKeditor/_samples/asp/ existem vários exemplos, iremos utilizar o sample04.asp.

Deste arquivo copie:

e cole no início de sua página de inserção e alteração de dados, no local onde está seu textarea, cole a outra parte do código

<%
Dim sBasePath
sBasePath = Request.ServerVariables(“PATH_INFO”)
sBasePath = Left( sBasePath, InStrRev( sBasePath, “/_samples” ) )
Dim oFCKeditor
Set oFCKeditor = New FCKeditor
oFCKeditor.BasePath = sBasePath
If Request.QueryString(“Skin”) “” Then
oFCKeditor.Config(“SkinPath”) = sBasePath + “editor/skins/” & Server.HTMLEncode( Request.QueryString(“Skin”) ) + “/”
End If
oFCKeditor.Value = ” ”
oFCKeditor.Create “FCKeditor1″
%>

Note-se que apaguei todos os comentários.
Atenção! – A página de inserção e alteração de dados deve estar na pasta raiz do FCKeditor, no meu caso eu uso o diretório config.

Localizar os arquivos no servidor

Agora é a vez de localizarmos os arquivos no servidor, para não dar erros, localize:
FCKeditor/editor/filemanager/browser/default/connectors/asp/config.asp
Faça as mudanças, altere o trecho abaixo:

Dim ConfigIsEnabled
ConfigIsEnabled = true ‘aqui estará false, muda para true

Para:

Dim ConfigUserFilesPath
ConfigUserFilesPath = “/fotos/” ‘aqui coloca em qual diretório ele deve buscar os arquivos

Fazer o upload dos arquivos

Para fazer o upload dos arquivos, evite os erros, ache o arquivo:

FCKeditor/editor/filemanager/upload/asp/config.asp

Faça as seguintes mudanças:

Dim ConfigIsEnabled
ConfigIsEnabled = true] ‘aqui estava false, você muda para true

Nesse trecho:

Dim ConfigUserFilesPath
ConfigUserFilesPath = “/fotos/” ‘aqui você mostra o diretório onde serão upados os arquivos

Estamos usando o diretório fotos, verifique sempre se o diretório que você está setando em seus arquivos config. está criado, preferencialmente que seja um diretório no diretório raiz do site. Não esqueça das permissões de escrita no diretório indicado.

Sempre que for mudar o diretório, use a / no final, exemplo /fotos/, /banco/, não esqueça a barra no final pois ela será necessária na função de FSO do FCKeditor para ciriar subdiretórios,como é o caso de imagens, flash e outros, pois para cada extensão de arquivo, o fckeditor usa um subdiretório.

O parent path conhecido como “..”, não está disponível, isso se deve por resolução da Microsoft que o desabilitou por padrão na versão 6 do IIS. Então não use ../../../fotos/
O Server.MapPath sempre aponta para a raiz de seu site, ou seja, se estiver na pasta “/includes/libs/” e quiser apontar para o arquivo “/db/meu.mdb”, use Server.MapPath (“/db/meu.mdb”);
Alterando a Largura e Altura do Textarea

Agora vamos para o arquivo FCKeditor/ FCKeditor.asp

Encontre o trecho:

Private Sub Class_Initialize()
sBasePath = “/config/”
sWidth = “465″
sHeight = “450″
sToolbarSet = “Default”
sValue = “”

Nas linhas

sWidth = “465″
sHeight = “450″

Vvocê pode mudar para a largura ou altura que quiser, se for em pixels, não é necessário usar o px, use apenas os números.

Diretório base

Na linha do arquivo /FCKeditor.asp:
sBasePath = “/config/”
Altere para config, o seu pode estar como /FCKeditor/, aqui é necessário você mudar para o nome do diretório onde estão os arquivos, para não acontecer os erros de xlm que geralmente acontecem.
Alterar os dados do bd com o FCKeditor
Para alterar os dados do banco de dados com o FCKeditor , você pode recuperar os dados do campo dentro do textarea, proceda da seguinte forma:

Na página altere os dados:

Para:

Você deve aplicar práticas de arquitetura e design e incorporar considerações de implantação e diretivas de segurança corporativas durante as fases iniciais do projeto. Se isso não for feito, poderá resultar em aplicativos que não podem ser implantados em uma infra–estrutura existente sem comprometer a segurança.
Este módulo apresenta um conjunto de diretrizes de segurança para projeto e arquitetura. Ele foi organizado por categoria de vulnerabilidade dos aplicativos comuns. São as áreas principais de segurança dos aplicativos da Web e são as mesmas onde os erros ocorrem com mais freqüência.

Objetivos

Utilize este módulo para:

• Identificar as questões principais de projeto e arquitetura de aplicativos da Web seguros.
• Considerar as principais questões de implantação no momento do projeto.
• Projetar estratégias para melhorar a validação da entrada do aplicativo da Web.
• Criar mecanismos seguros de autenticação e gerenciamento de sessões.
• Escolher um modelo de autorização apropriado.
• Implementar práticas eficientes de gerenciamento de contas e proteger as sessões dos usuários.
• Utilizar criptografia para oferecer privacidade, não–recusa, proteção contra violações e autenticação.
• Evitar a manipulação de parâmetros.
• Criar estratégias de auditoria e log.

Aplicação

Embora contidas no livro sobre segurança ASP.NET, as informações deste módulo são importantes para qualquer pessoa interessada em desenvolver aplicativos da Web seguros.

Como utilizar este módulo

O foco deste módulo está nas diretrizes e nos princípios que você deve seguir ao projetar um aplicativo.

Para aproveitar ao máximo este módulo:

• Conheça as ameaças ao seu aplicativo para que você possa garantir que isso seja solucionado pelo seu projeto.
Leia, “Ameaças e Contramedidas”, para entender as ameaças a considerar. O módulo 2 relaciona as ameaças que podem prejudicar seu aplicativo. Considere essas ameaças durante a fase de projeto.
• Use uma abordagem sistemática para as áreas principais nas quais o aplicativo poderia ficar vulnerável a ataques. Pontos nos quais se concentrar: considerações sobre a implantação; validação da entrada; autenticação e autorização; criptografia e confidencialidade dos dados; gerenciamento de configuração, sessões e exceções e auditoria e log adequados para garantir a criação de contas.

Questões de arquitetura e projeto para aplicativos da Web

Os aplicativos da Web apresentam a designers e desenvolvedores muitos desafios. Como o protocolo HTTP não mantém um registro das sessões por usuário, o registro passa a ser de responsabilidade do aplicativo. Como precursor disso, o aplicativo deve ser capaz de identificar o usuário utilizando alguma forma de autenticação. Como todas as decisões subseqüentes de autorização baseiam–se na identidade do usuário, é essencial que o processo de autenticação seja seguro e que o mecanismo de tratamento da sessão utilizado para monitorar os usuários autenticados seja igualmente bem protegido. Projetar os mecanismos de autenticação seguros e o gerenciamento de sessão é apenas parte das questões com que se deparam designers e desenvolvedores de aplicativos da Web. Outros desafios surgem porque a entrada e a saída de dados são feitos por redes públicas. Impedir a manipulação de parâmetros e a divulgação de dados confidenciais é outra questão importante.

As diretrizes de projeto apresentadas neste módulo estão organizadas por categoria de vulnerabilidade do aplicativo. A experiência mostra que um projeto deficiente nessas áreas em particular cria vulnerabilidades de segurança.

Vulnerabilidades do aplicativo da Web e possíveis problemas causados por um projeto ruim

Categoria da vulnerabilidade e possível problema causado por um projeto ruim

Validação da entrada Ataques realizados incorporando–se seqüências de caracteres mal–intencionadas em seqüências de caracteres de consulta, campos de formulário, cookies e cabeçalhos HTTP. Eles incluem execução de comandos, ataques XSS (cross-site scripting), inclusão de código SQL e estouro de buffer.

Autenticação Spoofing de identidade, quebra de senha, elevação de privilégios e acesso não–autorizado.

Autorização Acesso a dados confidenciais ou restritos, violação e execução de operações não–autorizadas.

Gerenciamento de configuração Acesso não–autorizado a interfaces administrativas, capacidade de atualizar dados de configuração e acesso não–autorizado a contas de usuários e perfis de contas.

Dados confidenciais Informações confidenciais divulgadas e violação de dados.

Gerenciamento de sessão Captura de identificadores de sessão, resultando em seqüestro de sessão e spoofing de identidade.

Criptografia Acesso a dados confidenciais, a credenciais de contas ou a ambos.

Manipulação de parâmetros Ataques de atravessamento de caminho, execução de comando e mecanismos para ignorar o controle de acesso, entre outros, levando à divulgação de informações ,elevação de privilégios e negação de serviço.

Gerenciamento de exceções Negação de serviço e divulgação de detalhes confidenciais do sistema.

Auditoria e log Falha ao indicar sinais de invasão, incapacidade de comprovar as ações de um usuário e dificuldades no diagnóstico de problemas.

Considerações para implantação

Durante a fase de design do aplicativo, analise as diretivas e os procedimentos da empresa junto a infra–estrutura na qual seu aplicativo será implantado. Freqüentemente, o ambiente de destino é rígido e o projeto do aplicativo deve refletir as restrições. Às vezes, são necessárias mudanças no projeto, por exemplo, devido a restrições de protocolo ou porta ou topologias de implantação específicas. Identifique as restrições no início da fase de projeto para evitar surpresas mais tarde e envolver membros das equipes de rede e infra–estrutura para ajudarem nesse processo.

Políticas e procedimentos de segurança

A diretiva de segurança determina o que os aplicativos podem fazer e o que os usuários do aplicativo têm permissão para fazer. O mais importante: ela define restrições para determinar o que os aplicativos e os usuários não podem fazer. Identifique e trabalhe com a estrutura definida pela diretiva de segurança da empresa ao projetar os aplicativos para garantir que você não está violando a diretiva, o que impedirá a implantação do aplicativo.

Componentes da infra–estrutura de rede

Certifique–se de que você entendeu a estrutura de rede do ambiente de destino e os requisitos básicos de segurança da rede em termos de regras de filtragem, restrições de porta, protocolos suportados e assim por diante.
Identifique como firewalls e suas diretivas podem afetar o projeto e a implantação do aplicativo. Pode haver firewalls para separar da rede interna os aplicativos ligados diretamente à Internet. Pode haver firewalls adicionais do banco de dados. Eles podem afetar as portas de comunicação possíveis e, portanto, as opções de autenticação do servidor Web para servidores de aplicativos e de banco de dados remotos. Por exemplo, a autenticação do Windows requer portas adicionais.
Na fase de projeto, considere quais protocolos, portas e serviços podem acessar os recursos internos a partir de servidores Web localizados na rede de perímetro. Identifique também os protocolos e as portas necessários ao projeto do aplicativo e analise as ameaças que podem surgir com a abertura de novas portas ou com o uso de novos protocolos.
Comunique e registre qualquer consideração sobre a segurança na camada da rede e do aplicativo e qual componente cuidará disso. Isso evita que faltem controles de segurança quando as equipes de desenvolvimento e de rede assumirem que a outra equipe está cuidado do assunto. Preste atenção às defesas de segurança que o aplicativo espera que a rede forneça. Considere as implicações de uma alteração na configuração da rede. Quanto você perderá de segurança se implementar uma alteração específica na rede?

Topologias de implantação

A topologia de implantação do aplicativo e se existe uma camada de aplicativo remota são considerações importantes a serem incorporadas ao seu projeto. Se existir uma camada de aplicativo remota, você terá que considerar como proteger a rede entre os servidores para eliminar a ameaça de espionagem da rede e para fornecer privacidade e integridade aos dados confidenciais.

Considere também identificar o fluxo e as contas que serão utilizadas para autenticação da rede quando o aplicativo conectar–se com servidores remotos. Uma abordagem comum é utilizar pelo menos uma conta de processo privilegiada e criar uma conta duplicada (espelho) no servidor remoto com a mesma senha. Como alternativa, convém utilizar uma conta de processo de domínio, que facilita a administração, mas é mais problemática de proteger devido à dificuldade de limitar o uso da conta pela rede. Um firewall intermediário ou domínios separados sem relações de confiança geralmente fazem com que a abordagem de conta local seja a única opção viável.

Intranet, extranet e Internet

Cada um desses cenários de uso do aplicativo apresenta desafios de projeto. As questões a considerar incluem: Como você conduzirá a identidade do chamador em várias camadas de aplicativo até os recursos back–end? Onde será feita a autenticação? Você pode confiar na autenticação feita no front–end e então utilizar uma conexão confiável para acessar recursos de back–end? No caso da extranet, você também deve considerar se confia nas contas dos parceiros.
Para obter mais informações sobre questões específicas para esses e outros cenários, consulte as seções “Intranet Security”, “Extranet Security” e “Internet Security” de “Building Secure ASP.NET Web Applications: Authentication, Authorization, and Secure Communication” em [url="http://msdn.microsoft.com/library/en-us/dn...ecnetlpMSDN.asp"]http://msdn.microsoft.com/library/en-us/dn…ecnetlpMSDN.asp[/url] (em inglês).

Validação da entrada

A validação da entrada é um desafio e o peso de uma solução cai sobre os ombros dos desenvolvedores do aplicativo. No entanto, a validação da entrada correta é uma das medidas de defesa mais fortes contra os ataques a aplicativos realizados atualmente. A validação da entrada correta é uma contramedida eficiente que pode ajudar a impedir ataques de scripts em sites, inclusão de código SQL e estouro do buffer, entre outros ataques de entrada.
A validação da entrada é difícil porque não há uma resposta única a o que constitui uma entrada válida entre os aplicativos e nem mesmo em cada aplicativo. Da mesma forma, não há uma única definição de entrada mal–intencionada. Além disso, o que o aplicativo faz com essa entrada influencia o risco de exploração. Por exemplo, você armazena dados para serem utilizados por outros aplicativos ou o seu aplicativo usa a entrada feita em outras fontes de dados por outros aplicativos?

As práticas a seguir melhoram a validação da entrada do aplicativo da Web:

• Considere que todas as entradas são mal–intencionadas.
• Centralize a sua abordagem.
• Não confie na validação do lado do cliente.
• Tenha cuidado com questões de canonização.
• Restrinja, rejeite e limpe a entrada.

Considere que todas as entradas são mal–intencionadas

A validação da entrada começa com a suposição fundamental de que toda entrada é mal–intencionada até que se prove o contrário. Independentemente de a entrada ter origem em um serviço, um compartilhamento de arquivo, um usuário ou de um banco de dados, valide a entrada se a fonte estiver fora do limite confiável. Por exemplo, se você chamar um Web Service externo que retornar seqüências de caracteres, como você sabe se não foram inseridos comandos mal–intencionados? Além disso, se houver vários aplicativos gravando dados em um banco de dados compartilhado, ao ler os dados, como saber se eles são seguros?

Centralize a sua abordagem

Faça da estratégia de validação da entrada um elemento básico do projeto do aplicativo. Considere uma abordagem centralizada para validação, por exemplo, utilizando um código comum de validação e filtragem em bibliotecas compartilhadas. Isso garante que as regras de validação serão aplicadas de forma consistente. Isso também reduz o trabalho de desenvolvimento e ajuda na manutenção futura.
Em muitos casos, campos individuais requerem validação específica, por exemplo, com expressões regulares desenvolvidas especialmente. No entanto, você pode freqüentemente melhorar rotinas comuns para validar campos utilizados regularmente, como endereços de email, cargos, nomes, endereços postais (incluindo CEP) e assim por diante.

Não confie na validação do lado do cliente

O código do lado do servidor deve executar sua própria validação. E se um invasor ignorar ou desativar as rotinas de script do lado do cliente, por exemplo, desativando o JavaScript? Use validação no lado do cliente para ajudar a reduzir o número de idas e vindas ao servidor, mas não confie nela para a segurança. Esse é um exemplo de defesa profunda.

Tenha cuidado com questões de canonização

Dados em forma canônica estão na sua forma padrão ou mais simples. Canonização é o processo de converter dados em sua forma canônica. Caminhos de arquivo e URLs são particularmente sujeitos a problemas de canonização e exploração bem conhecidas são o resultado direto de bugs de canonização. Por exemplo, considere a seqüência de caracteres a seguir que contém um arquivo e o caminho em sua forma canônica.

c:\temp\algumarquivo.dat

As seqüências de caracteres a seguir também poderiam representar o mesmo arquivo.
algumarquivo.dat

c:\temp\subdir\..\algumarquivo.dat
c:\ temp\ algumarquivo.dat
..\algumarquivo.dat
c%3A%5Ctemp%5Csubdir%5C%2E%2E%5Calgumarquivo.dat

No último exemplo, os caracteres foram especificados na forma hexadecimal:

• %3A representa o sinal dois–pontos.
• %5C representa uma barra invertida.
• %2E representa um ponto.

Geralmente, você deve tentar evitar projetar aplicativos que aceitam nomes de arquivo na entrada do usuário para evitar problemas de canonização. Em vez disso, considere projetos alternativos. Por exemplo, deixe o aplicativo determinar o nome do arquivo para o usuário.

Se você aceitar nomes de arquivo na entrada, certifique–se de que eles estejam estritamente formados antes de tomar decisões de segurança como autorizar ou negar acesso ao arquivo especificado.

Restrinja, rejeite e limpe a entrada

A melhor abordagem para validar a entrada é restringir desde o começo o que será permitido. É muito mais fácil validar dados de tipos, padrões e intervalos conhecidos que validá–los procurando caracteres inválidos conhecidos. Quando você projeta o aplicativo, sabe o que ele espera. O intervalo de dados válidos geralmente é um conjunto mais finito que o de entradas mal–intencionadas possíveis. No entanto, para uma defesa mais detalhada, convém rejeitar a entrada inválida conhecida e então limpá–la.

Para criar uma estratégia de validação da entrada eficiente, conheça as abordagens a seguir e suas exigências:

• Restringir a entrada.
• Validar dados por tipo, tamanho, formato e intervalo.
• Rejeitar dados inválidos.
• Limpar a entrada.

Restringir a entrada

Restringir a entrada refere–se a aceitar dados bons. Esta é a melhor abordagem. A idéia é definir um filtro de entradas aceitáveis utilizando tipo, tamanho, formato e intervalo. Defina o que é uma entrada aceitável para os campos do aplicativo e a aplique. Rejeite o restante como dados inválidos.
A restrição da entrada deve envolver a definição de conjuntos de caracteres no servidor para que você possa estabelecer a forma canônica da entrada de maneira localizada.

Validar os dados por tipo, tamanho, formato e intervalo

Use uma verificação de tipo rígida da entrada de dados sempre que possível, por exemplo, em classes utilizadas para manipular e processar os dados da entrada e em rotinas de acesso a dados. A exemplo disto, utilize procedimentos armazenados com parâmetros para acessar dados a fim de aproveitar a verificação de tipo dos campos de entrada.
Verifique também os campos de seqüências de caracteres e, muitas vezes, se seu formato é apropriado. Por exemplo, CEPs, números de RG, etc. têm formatos definidos que podem ser validados utilizando–se expressões regulares. A verificação completa não é a única boa prática de programação; ela dificulta que um invasor explore o código. O invasor pode passar pela verificação de tipo, mas a verificação de tamanho pode dificultar a execução de seu ataque favorito.

Rejeitar dados inválidos

Rejeite dados “inválidos”, mas não dependa totalmente dessa abordagem. Geralmente, ela é menos eficiente que utilizar a abordagem de “permissão” descrita anteriormente e é melhor usá–la de forma combinada. Para negar dados inválidos, assume–se que o aplicativo conhece todas as variações de uma entrada mal–intencionada. Lembre–se de que existem várias formas de representar caracteres. Esse é um outro motivo pelo qual a “permissão” é a abordagem preferida.
Embora seja útil para aplicativos que já estão em uso e quando você não pode arcar com alterações significativas, a abordagem de “negação” não é tão robusta como a de “permissão” pode os dados inválidos, como padrões que podem ser utilizados para identificar ataques comuns, não são constantes. Os dados válidos são constantes enquanto os dados inválidos podem variar periodicamente.

Limpar a entrada

Quando falamos em limpeza, significa transformar dados possivelmente mal–intencionados em dados seguros. Isso pode ser útil quando o intervalo de entrada permitido não pode garantir que a entrada é segura. Isso inclui qualquer coisa desde separar um valor nulo do final de uma seqüência de caracteres fornecida pelo usuário até remover valores para que sejam tratados como literais.
Outro exemplo comum de limpeza da entrada de aplicativos da Web é utilizar codificação de URL ou HTML para combinar dados e tratá–los como texto literal em vez de como script executável. Os métodos de HtmlEncode removem caracteres HTML e UrlEncode codificam um URL para que ele seja uma solicitação URI válida.

Na prática

Seguem exemplos aplicados a campos de entrada comuns utilizando as abordagens citadas:

• Campo Sobrenome. Este é um bom exemplo de onde a restrição da entrada é apropriada. Nesse caso, convém restringir os dados da seqüência de caracteres no intervalo ASCII A–Z e a–z e também em hífens e apóstrofes (apóstrofes não significam nada para o SQL) para tratar nomes como O’Dell. Também é ideal limitar a extensão ao maior valor esperado.
• Campo Quantidade. Este é outro caso em que a restrição da entrada funciona bem. Neste exemplo, convém utilizar uma restrição simples de tipo e intervalo. Por exemplo, os dados da entrada podem precisar ser um número inteiro positivo entre 0 e 1000.
• Campo Texto livre. Os exemplos incluem campos de comentário em quadros de discussão. Nesse caso, convém permitir o uso de letras e espaços além de caracteres comuns, como apóstrofes, vírgulas e hífens. O conjunto do que é permitido não inclui sinais de maior que e menor que, chaves e colchetes.
Alguns aplicativos podem permitir que os usuários marquem o texto utilizando um conjunto finito de caracteres de script, como negrito “” e itálico “”, ou até mesmo incluam um link para o URL favorito. No caso de um URL, a validação deve codificar o valor para que ele seja tratado como URL.

Um aplicativo da Web existente que não valida a entrada do usuário. Em um cenário ideal, o aplicativo verifica se a entrada de cada campo ou ponto de entrada é aceitável. No entanto, se você já possui um aplicativo da Web que não valida a entrada do usuário, você precisa de uma abordagem “quebra galho” para reduzir o risco até que seja possível aprimorar a estratégia de validação da entrada do aplicativo. Embora nenhuma das abordagens a seguir garantam um tratamento seguro da entrada, pois dependem de fatores como de onde vem a entrada e como ela será utilizada no aplicativo, elas são empregadas atualmente como correções rápidas para melhorar a segurança em curto prazo:

• Codificar como HTML e URL a entrada do usuário ao gravar de volta no cliente. Nesse caso, considera–se que nenhuma entrada é tratada como HTML e todas as saída são gravadas de volta de forma protegida. Essa é uma ação de limpeza.
• Rejeitar caracteres de script mal-intencionados. Esse é um caso de rejeição de entrada inválida conhecida. Nesse caso, um conjunto configurável de caracteres mal–intencionados é utilizado para rejeitar a entrada. Como descrito anteriormente, o problema dessa abordagem é um dado considerado inválido de acordo com o contexto.

Autenticação

Autenticação é o processo pelo qual se determina a identidade do chamador. Existem três aspectos a considerar:

• Identificar onde a autenticação é necessária no aplicativo. Geralmente, ela é requerida sempre que um limite confiável é ultrapassado. Os limites confiáveis normalmente incluem conjuntos, processos e hosts.
• Validar quem é o chamador. Os usuários geralmente se autenticam com nomes de usuário e senhas.
• Identificar o usuário nas solicitações subseqüentes. Isso requer alguma forma de identificador de autenticação.
Muitos aplicativos da Web usam um mecanismo de senha para autenticar usuários, sendo que o usuário fornece um nome de usuário e uma senha em formato HTML. As questões a considerar nesse caso incluem:
• Os nomes de usuário e senhas são enviados em texto sem formatação por um canal inseguro? Se sim, um invasor pode utilizar um software de monitoramento de rede para espionar e capturar as credenciais. A contramedida aqui é proteger o canal de comunicação utilizando SSL (Secure Socket Layer).
• Como as credenciais são armazenadas? Se você estiver armazenando nomes de usuário e senhas em texto sem formatação, em arquivos ou em um banco de dados, está procurando problemas. E se o diretório do aplicativo não estiver configurado corretamente e um invasor procurar um arquivo e baixar seu conteúdo ou incluir uma conta de logon com privilégios? E se um administrador descontente levar seu banco de dados de nomes de usuário e senhas?
• Como as credenciais são verificadas? Não é necessário armazenar senhas de usuário se a única finalidade for verificar se o usuário conhece a senha. Em vez disso, você pode armazenar um verificador na forma de um valor de hash e recalcular o hash utilizando o valor fornecido pelo usuário durante o processo de logon. Para eliminar a ameaça de um ataque de dicionário contra o armazenamento de credenciais, utilize senhas de alta segurança e combine um valor falso gerado aleatoriamente com o hash da senha.
• Como o usuário autenticado é identificado após o logon inicial? É necessária alguma forma de permissão de autenticação como, por exemplo, um cookie de autenticação. Como o cookie é protegido? Se ele for enviado por um canal desprotegido, um invasor pode capturá–lo e usá–lo para acessar o aplicativo. Um cookie de autenticação roubado é um logon roubado.

As práticas a seguir melhoram a autenticação do aplicativo da Web:

• Separar áreas públicas e restritas.
• Utilizar diretivas de bloqueio de conta para as contas de usuário final.
• Utilizar senhas com data de validade.
• Poder desativar contas.
• Não armazenar senhas nos armazenamentos de usuários.
• Exigir senhas de alta segurança.
• Não transmitir senhas em texto sem formatação.
• Proteger os cookies de autenticação.

Separar áreas públicas e restritas

A área pública do seu site pode ser acessada por qualquer usuário de forma anônima. As áreas restritas só podem ser acessadas por pessoas específicas e os usuários devem ser autenticados no site. Considere um site comum de uma loja. Você pode navegar pelo catálogo de produtos de forma anônima. Quando você inclui itens no carrinho de compra, o aplicativo identifica você utilizando um identificador de sessão. Finalmente, quando você faz o pedido, realiza uma transação segura. Nesse ponto, você precisa fazer logon para autenticar sua transação pela SSL.
Dividindo o site em áreas de acesso pública e restrita, você pode aplicar regras de autenticação e autorização a todo o site e limitar o uso da SSL. Para evitar a sobrecarga desnecessária sobre o desempenho provocado pela SSL, projete o site de modo a limitar o uso da SSL nas áreas que requerem acesso autenticado.
Utilizar diretivas de bloqueio de conta para as contas de usuário final

Desative contas de usuário final ou a gravação de eventos em log depois de um número determinado de tentativas de logon sem sucesso. Se você estiver utilizando a autenticação do Windows, como NTLM ou o protocolo Kerberos, essas diretivas podem ser configuradas e aplicadas automaticamente pelo sistema operacional. Com autenticação de formulários, essas diretivas são responsabilidade do aplicativo e devem ser incorporadas ao projeto do mesmo.
Tenha cuidado para que as diretivas de bloqueio de contas não sejam utilizadas em ataques de negação de serviço. Por exemplo, contas de serviço padrão conhecidas, como IUSR_MACHINENAME, devem ser substituída por nomes de contas personalizados para evitar que um invasor que consiga obter o nome do servidor Web do IIS (Internet Information Services) bloqueie essa conta vital.

Utilizar senhas com data de validade

As senhas não devem ser estáticas e sim alteradas como parte da rotina de manutenção de senha por meio de períodos de validade da senha. Considere fornecer esse tipo de recurso ao projetar o aplicativo.

Poder desativar contas

Se o sistema estiver comprometido, poder invalidar deliberadamente credenciais ou desativar contas pode evitar outros ataques.

Não registrar senhas nos armazenamentos de usuários

Se você deve verificar as senhas, não é necessário realmente armazená–las. Em vez disso, armazene um valor de hash unidirecional e então recalcule o hash utilizando as senhas fornecidas pelos usuários. Para eliminar a ameaça de um ataque de dicionário contra o armazenamento do usuário, utilize senhas de alta segurança e incorpore um valor falso gerado com a senha.

Exigir senhas de alta segurança

Não facilite a quebra de senhas para os invasores. Existem muitas instruções, mas uma prática geral é exigir no mínimo oito caracteres e uma mistura de letras maiúsculas e minúsculas, números e caracteres especiais. Tanto se você estiver utilizando uma plataforma para aplicar essas regras ou quanto se estiver desenvolvendo sua própria validação, essa etapa é necessária para combater ataques de força bruta, nos quais o invasor tenta quebrar uma senha sistematicamente por tentativa e erro. Utilize expressões regulares para ajudar na validação de senhas de alta segurança.

Não transmitir senhas em texto sem formatação

Senhas em texto sem formatação enviadas por uma rede ficam vulneráveis à espionagem. Para acabar com essa ameaça, você precisa proteger o canal de comunicação como, por exemplo, utilizar SSL para criptografar o tráfego.

Proteger os cookies de autenticação

Um cookie de autenticação roubado é um logon roubado. Proteja as permissões de autenticação utilizando criptografia e canais de comunicação seguros. Além disso, limite o tempo de validade de uma permissão de autenticação para combater a ameaça de spoofing que pode resultar de ataques de repetição, nos quais o invasor captura o cookie e o usa para obter acesso ilegal ao site. Reduzir o tempo limite do cookie não evita ataques de repetição, mas limita o tempo pelo qual o invasor terá acesso ao site utilizando o cookie roubado.

Autorização

A autorização determina o que a identidade autenticada pode realizar e quais recursos ela acessa. Uma autorização incorreta ou ineficaz leva à divulgação de informações e à violação dos dados. Defesa profunda é o princípio básico de segurança utilizado na estratégia de autorização do aplicativo.

As práticas a seguir melhoram a autorização do aplicativo da Web:

• Utilizar vários gatekeepers.
• Restringir o acesso do usuário a recursos no nível do sistema.
• Considerar a granulação da autorização.

Utilizar vários gatekeepers

No lado do servidor, você pode utilizar as diretivas do IPSec (IP Security Protocol) para definir restrições do host a fim de restringir a comunicação entre servidores. Por exemplo: uma diretiva IPSec poderia restringir a conexão de qualquer host separado de um servidor Web com um servidor de banco de dados. O IIS fornece permissões da Web e restrições IP/DNS (Internet Protocol/Domain Name System). As permissões da Web do IIS são válidas para todos os recursos solicitados pelo HTTP independentemente do usuário. Elas não oferecem proteção se um invasor tiver como realizar logon no servidor. Por isso, as permissões de NTFS consentem que você especifique listas de controle de acesso por usuário. Finalmente, o ASP.NET fornece autorização de URL e de arquivo junto a demanda de permissão principal. Combinando esses gatekeepers, você pode desenvolver uma estratégia de autorização eficiente.

Restringir o acesso do usuário a recursos no nível do sistema

Os recursos no nível do sistema incluem arquivos, pastas, chaves do registro, objetos do Active Directory, objetos do banco de dados, logs de evento, etc. Utilize as listas de controle de acesso do Windows para restringir quais usuários podem acessar quais recursos e os tipos de operação que eles podem executar. Preste atenção especialmente nas contas de usuário anônimas da Internet; utilize as listas de controle de acesso para restringi–las a recursos que negam acesso explicitamente a usuários anônimos.

Considerar a granulação da autorização

Existem três modelos comuns de autorização, cada um com graus diferentes de granulação e escalabilidade.
A abordagem mais granular depende de representação. O acesso aos recursos ocorre utilizando o contexto de segurança do chamador. As listas de controle de acesso do Windows dos recursos protegidos (geralmente arquivos ou tabelas, ou ambos) determinam se o chamador pode acessar o recurso. Se o aplicativo fornecer acesso basicamente a recursos específicos do usuário, essa abordagem pode ser válida. Sua vantagem é que a auditoria no nível do sistema operacional pode ser feita entre as camadas do aplicativo, pois o contexto de segurança do chamador original flui no nível do sistema operacional e é utilizado para acessar recursos. No entanto, seu problema é a escalabilidade do aplicativo, pois não é possível estabelecer um pool de conexão eficiente para acessar o banco de dados. Como resultado, essa abordagem é encontrada com mais freqüência em aplicativos para intranet de escala limitada.

A abordagem menos granular, porém mais escalonável, utiliza a identificação de processo do aplicativo para acessar recursos. Ela oferece suporte ao pool de conexão ao banco de dados, mas isso significa que as permissões concedidas à identificação do aplicativo no banco de dados são comuns, independentemente da identificação do chamador original. A autorização principal é feita na camada intermediária lógica do aplicativo utilizando funções, agrupando usuários que compartilham os mesmos privilégios com relação ao aplicativo. O acesso a classes e métodos é restringido de acordo com a participação do chamador na função. Para oferecer suporte à recuperação de dados por usuário, uma abordagem comum é inclui uma coluna de identificação nas tabelas do banco de dados e utilizar parâmetros de consulta para restringir os dados recuperados. Por exemplo: você pode passar a identificação do chamador original para o banco de dados no nível do aplicativo (não do sistema operacional) por meio de parâmetros de procedimentos armazenados e gravar consultas semelhantes a estas:

SELECT field1, field2, field3 FROM Table1 WHERE {some search criteria} AND

UserName = @originalCallerUserName

Esse modelo é conhecido como subsistema confiável ou, às vezes, como modelo de servidor confiável.
A terceira opção é utilizar um conjunto limitado de identidades para acessar recursos com base na participação do chamador na função. Na verdade, trata–se de um híbrido dos dois modelos descritos anteriormente. Os chamadores são mapeados para funções na camada intermediária lógica do aplicativo e o acesso a classes e métodos é restrito de acordo com a participação na função. O acesso a recursos de downstream é feito utilizando um conjunto restrito de identidade determinado pela participação na função do chamador atual. A vantagem dessa abordagem é que as permissões podem ser atribuídas a logons separados no banco de dados e a regulagem da conexão ainda ser efetiva com diversos pools de conexões. A desvantagem é que a criação dos símbolos de acesso com vários segmentos utilizados para estabelecer contextos diferentes de segurança para acessar recursos de downstream utilizando a autenticação do Windows é uma operação com privilégios que requer contas de processo com privilégios. Isso vai contra o princípio de menos privilégios.

Gerenciamento de configuração

Considere atentamente a funcionalidade de gerenciamento de configuração do aplicativo da Web. A maioria dos aplicativos requer interfaces que permitem que desenvolvedores de conteúdo, operadores e administradores configurem o aplicativo e gerenciem itens como conteúdo de páginas da Web, contas de usuário, informações do perfil do usuário e seqüências de caracteres para conexão do banco de dados. Se houver suporte para administração remota, como as interfaces de administração são protegidas? As conseqüências de uma falha de segurança em uma interface administrativa podem ser graves, pois o invasor freqüentemente acaba utilizando privilégios de administrador e tem acesso direto a todo o site.

As práticas a seguir aumentam a segurança do gerenciamento da configuração do aplicativo da Web:

• Proteger as interfaces administrativas.
• Proteger o armazenamento da configuração.
• Manter privilégios administrativos distintos.
• Utilizar contas com processos e serviços com a menor quantidade de privilégios.

Proteger as interfaces administrativas

É importante que a funcionalidade de gerenciamento da configuração seja acessível somente por operadores e administradores autorizados. O principal é aplicar uma autenticação rígida nas interfaces administrativas, por exemplo, utilizando certificados.

Se possível, limite ou evite o uso da administração remota e exija que os administradores façam logon localmente. Se você precisar oferecer suporte a administração remota, use canais criptografados, por exemplo, com tecnologia de SSL VPN, devido à natureza confidencial dos dados transmitidos pelas interfaces administrativas. Considere também limitar a administração remota a computadores da rede interna utilizando diretivas IPSec para diminuir ainda mais o risco.

Proteger o armazenamento da configuração

Arquivos de configuração em texto, o registro e os bancos de dados são as opções comuns para armazenamento dos dados de configuração do aplicativo. Se possível, evitar utilizar arquivos de configuração no espaço da Web do aplicativo para evitar possíveis vulnerabilidades no servidor de configuração, resultando no download dos arquivos de configuração. Independentemente da abordagem utilizada, proteja o acesso ao armazenamento da configuração, por exemplo, utilizando as listas de controle de acesso do Windows ou permissões do banco de dados. Além disso, evite armazenar informações confidenciais, como seqüências de caracteres de conexão do banco de dados ou credenciais de contas, em texto sem formatação. Proteja esses itens utilizando criptografia e restrinja o acesso à chave do registro, ao arquivo ou à tabela que contém os dados criptografados.

Manter privilégios administrativos distintos

Se a funcionalidade suportada pelos recursos do gerenciamento da configuração do aplicativo varia de acordo com a função do administrador, considere autorizar cada função separadamente utilizando a autorização com base na função. Por exemplo: a pessoa responsável por atualizar o conteúdo estático do site não precisa ter permissão para alterar o limite de crédito de um cliente.
Utilizar contas com processos e serviços com a menor quantidade de privilégios
Um aspecto importante da configuração do aplicativo são as contas de processo utilizadas para executar processos no servidor Web e as contas de serviço utilizadas para acessar recursos de downstream e sistemas. Certifique–se de que essas contas estejam configuradas com a menor quantidade de privilégios. Se um invasor conseguir assumir o controle de um processo, a identificação do processo deve ter acesso extremamente restrito ao sistema de arquivos e a outros recursos do sistema para limitar os danos que podem ser causados

Dados confidenciais

Os aplicativos que lidam com informações particulares dos usuários, como números de cartão de crédito, endereços, registros médicos e outros, devem seguir etapas especiais para garantir que os dados permanecerão particulares e inalterados. Além disso, os segredos utilizados na implementação do aplicativo, como senhas e seqüências de conexão ao banco de dados, devem ser protegidos. A segurança de dados confidenciais é um problema enquanto os dados são armazenados em um local de armazenamento persistente e enquanto são transmitidos pela rede.

Segredos

Os segredos incluem senhas, seqüências de caracteres de conexão ao banco de dados e números de cartão de crédito. As práticas a seguir aumentam a segurança do tratamento dos segredos feito pelo aplicativo da Web:

• Não armazenar segredos se for possível evitar.
• Não armazenar segredos no código.
• Não armazenar conexões ao banco de dados, senhas ou chaves em texto sem formatação.
• Evitar armazenar segredos na LSA (autoridade de segurança local).
• Utilizar a DAPI (API de Proteção a Dados) para criptografar os segredos.

Não armazenar segredos se for possível evitar

Armazenar segredos em software de maneira totalmente segura é impossível. Um administrador, com acesso físico ao servidor, pode acessar os dados. Não é necessário armazenar um segredo quando tudo o que você precisa fazer é verificar se o usuário o conhece. Nesse caso, você pode armazenar um valor de hash que representa o segredo e calcula o hash utilizando o valor fornecido pelo usuário para verificar se o usuário conhece o segredo.

Não armazenar segredos no código

Não inclua os segredos no código. Mesmo que o código–fonte não seja exposto no servidor Web, é possível extrair constantes de seqüências de caracteres de arquivos executáveis compilados. Uma vulnerabilidade na configuração pode permitir que um invasor recupere o executável.
Não armazenar conexões ao banco de dados, senhas ou chaves em texto sem formatação
Evite armazenar segredos como seqüências de caracteres de conexões ao banco de dados, senhas ou chaves em texto sem formatação. Utilize criptografia e armazene seqüências de caracteres criptografadas.

Evitar armazenar segredos na LSA

Evitar a LSA porque o aplicativo requer privilégios administrativos para acessá–la. Isso viola o princípio de segurança básico de utilizar a menor quantidade de privilégios. Além disso, a LSA pode armazenar segredos somente em um número restrito de slots. O melhor é utilizar a DPAPI, disponível no Microsoft Windows® 2000 e nos sistemas operacionais posteriores.

Utilizar DPAPI para criptografar os segredos

Para armazenar segredos como seqüências de caracteres de conexão a banco de dados ou credenciais de serviço das contas, use DPAPI. A principal vantagem de utilizar a DPAPI é que o sistema da plataforma gerencia a chave de criptografia/descriptografia e isso não é problema para o aplicativo. A chave é vinculada a uma conta de usuário do Windows ou a um computador específico, dependendo dos sinalizadores passados para as funções da DPAPI.
A DPAPI é mais adequada para criptografar informações, pois pode ser recriada manualmente em caso de perda das chaves mestre, por exemplo, devido a um dano no servidor que exija a reinstalação do sistema operacional. Dados que não podem ser recuperados porque você conhece o valor sem formatação, por exemplo, detalhes do cartão de crédito do cliente, requerem uma abordagem alternativa que usa a criptografia com base em chave simétrica tradicional, como a utilizada no triplo DES.

Dados confidenciais por usuário

Dados confidenciais, como credenciais de logon, e dados no nível do aplicativo, como números de cartão de crédito, números de contas bancárias, etc., precisam ser protegidos. A privacidade por meio da criptografia e a integridade através de códigos de autenticação de mensagens (MAC) são os elementos principais.

As práticas a seguir aumentam a segurança de dados confidenciais por usuário em aplicativos da Web:

• Recuperar dados confidenciais sob demanda.
• Criptografar os dados ou proteger o canal de comunicação.
• Não armazenar dados confidenciais em cookies persistentes.
• Não transmitir dados confidenciais utilizando o protocolo HTTP–GET.

Recuperar dados confidenciais sob demanda

A melhor abordagem é recuperar dados confidenciais sob demanda quando eles forem necessários em vez de mantê–los ou armazená–los em cache na memória. Por exemplo: recupere o segredo criptografado quando ele for necessário, descriptografe–o e limpe a memória (variável) uutilize para manter o segredo em texto sem formatação. Se a questão for o desempenho, considere estas opções:

• Armazenar em cache o segredo criptografado.
• Armazenar em cache o segredo em texto sem formatação.

Armazenar em cache o segredo criptografado

Recupere o segredo quando o aplicativo for carregado e o armazene em cache na memória, descriptografando–o quando o aplicativo usá–lo. Apague a cópia em texto sem formatação quando ela não for mais necessária. Essa abordagem evita o acesso ao armazenamento de dados a cada solicitação.

Armazenar em cache o segredo em texto sem formatação

Evite a sobrecarga de descriptografar o segredo várias vezes e armazenar a cópia em texto sem formatação do segredo na memória. Essa é a abordagem menos segura, mas oferece o melhor desempenho. Teste as outras abordagens antes de achar que o ganho em desempenho compensa o risco de segurança maior.
Criptografar os dados ou proteger o canal de comunicação

Se você estiver enviando ao cliente dados confidenciais pela rede, criptografe–os ou proteja o canal. Uma prática comum é utilizar SSL entre o cliente e o servidor Web. Entre servidores, a abordagem cada vez mais comum é utilizar IPSec. Para proteger dados confidenciais que trafegam entre vários intermediários, por exemplo, mensagens SOAP (Simple Object Access Protocol) do Web Service, usam criptografia no nível da mensagem.

Não armazenar dados confidenciais em cookies persistentes

Evite armazenar dados confidenciais em cookies persistentes. Se você armazenar dados em texto sem formatação, o usuário final poderá ver e modificar os dados. Se você criptografar os dados, o gerenciamento de chaves pode ser um problema. Por exemplo, a chave utilizada para criptografar os dados no cookie expirou e foi reciclada, a nova chave não consegue descriptografar o cookie persistente transmitido pelo navegador a partir do cliente.
Não transmitir dados confidenciais utilizando o protocolo HTTP–GET
Você pode evitar armazenar dados confidenciais utilizando o protocolo HTTP–GET porque ele usa seqüências de caracteres de consulta para transmitir dados. Não é possível proteger dados confidenciais utilizando seqüências de caracteres de consulta e estas são freqüentemente registradas pelo servidor

Gerenciamento de sessão

Os aplicativos da Web baseiam–se no protocolo HTTP independente, portanto, o gerenciamento da sessão é responsabilidade do aplicativo. A segurança da sessão é fundamental para a segurança geral do aplicativo.
As práticas a seguir aumentam a segurança do gerenciamento da sessão do aplicativo da Web:

• Utilizar SSL para proteger os cookies de autenticação da sessão.
• Criptografar o conteúdo dos cookies de autenticação.
• Limitar a duração da sessão.
• Proteger o estado da sessão contra acesso não autorizado.

Utilizar SSL para proteger os cookies de autenticação da sessão

Não transmita cookies de autenticação por conexões HTTP. Defina o cookie seguro corretamente nos cookies de autenticação, que instruem os navegadores a retornar os cookies ao servidor somente por conexões HTTPS.
Criptografar o conteúdo dos cookies de autenticação
Criptografe o conteúdo do cookie mesmo que você esteja utilizando SSL. Isso evita que um invasor visualize ou modifique o cookie se ele conseguir roubá–lo por meio de um ataque de scripts através de sites. Nesse caso, o invasor ainda poderia utilizar o cookie para acessar o aplicativo, mas somente enquanto ele fosse válido.

Limitar a duração da sessão

Reduza o tempo de duração das sessões para reduzir o risco de seqüestro de sessão e ataques de repetição. Quanto menor a sessão, menos tempo o invasor terá para capturar um cookie da sessão usá–lo para acessar o aplicativo.
Proteger o estado da sessão contra acesso não autorizado

Considere como o estado da sessão será armazenado. Para um melhor desempenho, você pode armazená–lo no espaço de endereço do processo do aplicativo da Web. No entanto, essa abordagem tem escalabilidade limitada e implicações em cenários de Web farm, nos quais não há garantia de que as solicitações do mesmo usuário serão tratadas pelo mesmo servidor. Nesse caso, é necessário um estado fora do processo em um servidor de estado dedicado ou um armazenamento de estado persistente em um banco de dados compartilhado. O ASP.NET suporte as três opções.
Você deve proteger o link de rede entre o aplicativo da Web e o armazenamento de estado utilizando IPSec ou SSL para reduzir o risco de espionagem. Considere também como o aplicativo da Web será autenticado pelo armazenamento de estado. Utilize a autenticação do Windows sempre que possível para evitar transmitir credenciais de autenticação em texto sem formatação pela rede e para aproveitar as diretivas de contas seguras do Windows.

Criptografia

A criptografia em sua forma básica oferece o seguinte:

• Privacidade (Confidencialidade). Esse serviço mantém um segredo como confidencial.
• Não-repúdio (Autenticidade). Esse serviço garante que um usuário não pode negar o envio de uma mensagem em particular.
• À prova de violação (Integridade). Esse serviço evita que os dados sejam alterados.
• Autenticação. Esse serviço confirma a identidade do remetente de uma mensagem.

Os aplicativos da Web freqüentemente usam criptografia para protege dados em armazenamentos persistentes ou enquanto são transmitidos pelas redes. As práticas a seguir aumentam a segurança do aplicativo da Web quando você utilizar criptografia:

• Não desenvolver sua própria criptografia.
• Manter dados descriptografados próximos do algoritmo.
• Utilizar o algoritmo e o tamanho de chave corretos.
• Proteger as chaves de criptografia.

Não desenvolver sua própria criptografia

Algoritmos e rotinas de criptografia são notoriamente difíceis de desenvolver com sucesso. Como resultado, você deve utilizar os serviços de criptografia testados fornecidos pela plataforma. Isso inclui o .NET Framework e o sistema operacional subjacente. Não desenvolva implementações personalizadas porque, geralmente, resultam em uma proteção fraca.

Manter dados descriptografados próximos do algoritmo

Ao transmitir texto sem formatação a um algoritmo, não obtenha os dados até que você esteja pronto para usá–los e armazená–los no menor número de variáveis possível.

Utilizar o algoritmo e o tamanho de chave corretos

É importante garantir que você escolheu o algoritmo certo para o trabalho certo e que você está utilizando um tamanho de chave que fornece um grau suficiente de segurança. Chaves maiores geralmente aumentar a segurança. A lista a seguir resume os principais algoritmos com o tamanho de chave que cada um usa:

• Chave DES (Data Encryption Standard) de 64 bits (8 bytes)
• Chave triplo DES de 128 bits ou chave de 192 bits (16 ou 24 bytes)
• Chaves Rijndael de 128 – 256 bits (16 – 32 bytes)
• Chaves RSA de 384 – 16.384 bits (48 – 2.048 bytes)

Para criptografar dados maiores, utilize o algoritmo de criptografia simétrica Triplo DES. Para criptografia mais lenta e mais rígida de grandes quantidades de dados, use Rijndael. Para criptografar os dados que serão armazenados por curtos períodos, você pode considerar o uso de um algoritmo mais rápido, mas mais fraco, como o DES. Para assinaturas digitais, utilize RSA (Rivest, Shamir e Adleman) ou DAS (Digital Signature Algorithm). Para hash, utilize o SHA (Secure Hash Algorithm)1.0. Para hashes com chaves, utilize o HMAC (Hash–based Message Authentication Code) SHA1.0.

Proteger as chaves de criptografia

A chave de criptografia é um número secreto utilizado como entrada para processos de criptografia e descriptografia. Para que os dados criptografados continuem seguros, a chave deve ser protegida. Se um invasor comprometer a chave de descriptografia, os dados criptografados não estarão mais seguros.
As práticas a seguir ajudam a proteger as chaves de criptografia:

• Utilizar a DPAPI para evitar o gerenciamento de chaves.
• Mudar as chaves periodicamente.

Utilizar a DPAPI para evitar o gerenciamento de chaves

Como já foi citado, uma das maiores vantagens do uso da DPAPI é que a questão do gerenciamento de chaves fica a cargo do sistema operacional. A chave utilizada pela DPAPI é derivada da senha associada à conta de processo que aciona as funções da DPAPI. Use a DPAPI para deixar o trabalho de gerenciamento de chaves para o sistema operacional.

Mudar as chaves periodicamente

Geralmente, a probabilidade de um segredo estático ser descoberto com o tempo é maior. As questões que você não pode esquecer incluem: Você o anotou em algum lugar? Bob, o administrador que detém os segredos, mudou de cargo ou saiu da empresa? Não use demais as chaves.

Manipulação de parâmetros

Com ataques de manipulação de parâmetros, o invasor modifica os dados transmitidos entre o cliente e o aplicativo da Web. Podem ser dados enviados por meio de seqüências de caracteres de consulta, campos de formulário, cookies ou em cabeçalhos HTTP. As práticas a seguir ajudam a proteger a manipulação de parâmetros do aplicativo da Web:

• Criptografar o estado de cookies confidenciais.
• Certificar–se de que os usuários não ignoram as verificações.
• Validar todos os valores enviados a partir do cliente.
• Não confiar nas informações do cabeçalho HTTP.

Criptografar o estado de cookies confidenciais

Os cookies podem conter dados confidenciais, como identificadores de sessão, ou dados utilizados no processo de autorização do lado do servidor. Para proteger esse tipo de dados contra manipulação não–autorizada, criptografe o conteúdo do cookie.

Certificar–se de que os usuários não ignoram as verificações

Certifique–se de que os usuários não ignoram as verificações manipulando parâmetros. Os parâmetros de URL podem ser manipulados pelos usuários finais através da caixa de texto de endereço do navegador. Por exemplo: o URL [url="http://www.//IDsessão=10"]http://www.//IDsessão=10[/url] possui um valor de 10 que pode ser alterado para algum número aleatório para receber uma saída diferente. Certifique–se de verificar isso no código do lado do servidor, não no JavaScript no lado do cliente, que pode ser desativado no navegador.

Validar todos os valores enviados a partir do cliente

Restrinja os campos que o usuário pode inserir e modificar e valide todos os valores provenientes do cliente. Se você predefiniu valores em campos de formulário, os usuários podem alterá–los e retorná–los para receber resultados diferentes. Permita somente valores bem conhecidos sempre que possível. Por exemplo, se o campo de entrada for um estado, somente entradas que correspondam ao código postal do estado devem ser permitidas.

Não confiar nas informações do cabeçalho HTTP

Os cabeçalhos HTTP são enviados no início das solicitações e das respostas HTTP. O aplicativo da Web deve certificar–se de que ele não baseia nenhuma decisão de segurança nas informações contidas nos cabeçalhos HTTP porque é fácil para um invasor manipular o cabeçalho. Por exemplo, o campo referencial do cabeçalho contém o URL da página da Web de onde ele provém. Não tome decisões de segurança com base no valor do campo referencial, por exemplo, verificar se a solicitação teve origem em uma página gerada pelo aplicativo da Web, pois o campo pode ser facilmente falsificado.

Gerenciamento de exceções

O tratamento seguro de exceções pode ajudar a evitar certos ataques de negação de serviço no nível do aplicativo e também pode ser utilizado para impedir que informações importantes no nível do sistema úteis aos invasores sejam retornadas ao cliente. Por exemplo, sem o tratamento correto de exceções, informações como detalhes do esquema do banco de dados, versões do sistema operacional, rastreamentos de pilha, nomes e caminho de arquivos, seqüências de caracteres de consulta do SQL e outras informações de valor para o invasor podem ser retornadas ao cliente.
Uma boa abordagem é projetar um gerenciamento de exceções centralizado e uma solução de registro em log e considerar a inclusão de ganchos no sistema de gerenciamento de exceções para oferecer suporte à instrumentação e ao monitoramento centralizado para ajudar os administradores de sistema.

As práticas a seguir ajudam a proteger o gerenciamento de exceções do aplicativo da Web:

• Não deixar vazar informações para o cliente.
• Registrar em log mensagens de erro com detalhes.
• Identificar as exceções.

Não deixar vazar informações para o cliente

No caso de falha, não exponha informações que poderiam resultar na divulgação de informações. Por exemplo, não exponha detalhes do rastreamento de pilha que incluam nomes de função e números de linha no caso de compilações para depuração (que não devem ser utilizadas em servidores de produção). Em vez disso, retorne mensagens de erro genéricas ao cliente.

Registrar em log mensagens de erro com detalhes
Envie mensagens de erro detalhadas ao log de erros. Envie o mínimo de informações ao usuário do serviço ou do aplicativo, como uma mensagem de erro genérica e uma identificação personalizada do log de erro que possa ser então mapeada até a mensagem detalhada nos logs de eventos. Certifique–se de não registrar no log senhas nem outros dados confidenciais.

Identificar as exceções

Utilize um tratamento de exceções estruturado e identifique condições de exceção. Isso evita que o aplicativo fique com um estado inconsistente que pode resulta na divulgação de informações. Isso também pode ajudar a proteger o aplicativo contra ataques de negação de serviço. Decida como propagar as exceções internamente no aplicativo e dê atenção especial a o que ocorre no limite do aplicativo.

Auditoria e log

Você deve executar atividades de auditoria e log nas camadas do aplicativo. Utilizando logs, é possível detectar atividades suspeitas. Elas freqüentemente indicam com antecedência um ataque devastador e os logs ajudam a resolver o risco de recusa quando os usuários recusam suas ações. Os arquivos de log podem ser exigidos em processos judiciais para provarem a transgressão dos acusados. Geralmente, o processo de auditoria é considerado mais autorizado se as auditorias forem geradas no momento exato em que um recurso é acessado e pelas mesmas rotinas que acessam o recurso.

As práticas a seguir aumentam a segurança do aplicativo da Web:

• Auditar e registrar em log o acesso entre as camadas do aplicativo.
• Considerar o fluxo de identificação.
• Registrar em log eventos importantes.
• Proteger arquivos de log.
• Fazer backup dos arquivos de log e os analisar regularmente.

Auditar e registrar em log o acesso entre as camadas do aplicativo

Audite e registre em log o acesso entre as camadas do aplicativo no caso de não–repúdio. Use uma combinação de log no nível do aplicativo e recursos de auditoria da plataforma, como a auditoria do Windows, do IIS e do SQL Server.

Considerar o fluxo de identificação

Considere como o aplicativo transmitirá a identificação do chamador entre as várias camadas do aplicativo. Você tem duas opções básicas. Você pode transmitir a identificação do chamador no nível do sistema operacional utilizando a delegação do protocolo Kerberos. Isso permite o uso da auditoria no nível do sistema operacional. A desvantagem dessa abordagem é que ela afeta a escalabilidade, pois significa que não pode haver nenhum pool de conexão do banco de dados ativo na camada intermediária. Como alternativa, você pode transmitir a identificação do chamador no nível do aplicativo e utilizar identificações confiáveis para acessar recursos de back–end. Com essa abordagem, você tem que confiar na camada intermediária e existe um risco de recuso. Você deve gerar faixas de auditoria na camada intermediária que possam ser correlacionadas às faixas de auditoria de back–end. Para isso, você deve certificar–se de que os relógios dos servidores estão sincronizados, embora o Microsoft Windows 2000 e o Active Directory façam isso por você.

Registrar em log eventos importantes

Os tipos de eventos que devem ser registrados incluem tentativas de logon bem–sucedidas ou não, modificação de dados, recuperação de dados, comunicações de rede e funções administrativas, como ativar ou desativar o registro em log. Os logs devem inclui a hora do evento, a localização do evento incluindo o nome da máquina, a identificação do usuário atual, a identificação do processo que iniciou o evento e uma descrição detalhada do evento.

Proteger arquivos de log

Proteja os arquivos de log utilizando as listas de controle de acesso do Windows e restrinja o acesso a eles. Isso dificulta para os invasores a alteração dos arquivos de log para encobrir seus rastros. Reduza o número de pessoas que podem manipular os arquivos de log. Autorize acesso somente a contas altamente confiáveis, como as dos administradores.

Fazer backup dos arquivos de log e os analisar regularmente

Não há porquê criar um log se os arquivos de log nunca são analisados. Os arquivos de log devem ser removidos dos servidores de produção regularmente. A freqüência de remoção depende do nível de atividade do aplicativo. O projeto deve considerar o modo como os arquivos de log serão recuperados e movidos para servidores offline para análise. Quaisquer protocolos e portas adicionais abertos no servidor Web com essa finalidade devem ser fechados de forma segura.

Diretrizes de projeto do aplicativo

Categoria Diretrizes

Validação da entrada Não confiar na entrada; considerar a validação da entrada centralizada.

Não confiar na validação do lado do cliente. Ter cuidado com questões de canonização. Restringir, rejeitar e limpar a entrada. Validar dados por tipo, tamanho, formato e intervalo.

Autenticação Dividir o site nas áreas de acesso anônimo, identificado e autenticado. Utilizar senhas de alta segurança. Oferecer suporte para senhas com validade e desativação de conta. Não armazenar credenciais (utilizar hashes unidirecionais com valores falsos). Criptografar os canais de comunicação para proteger os identificadores de autenticação.
Transmitir cookies de autenticação de formulários somente por conexões HTTPS.

Autorização Utilizar contas com a menor quantidade de privilégios. Considerar a granulação da autorização.

Aplicar a separação de privilégios. Restringir o acesso do usuário a recursos no nível do sistema.

Gerenciamento de configuração Utilizar contas com processos e serviços com a menor quantidade de privilégios. Não armazenar credenciais em texto sem formatação. Utilizar autenticação e autorização rígidas nas interfaces administrativas.

Não utilizar a LSA. Proteger o canal de comunicação para administração remota. Evitar armazenar dados confidenciais no espaço da Web.

Dados confidenciais Evitar armazenar segredos. Criptografar dados confidencias transmitidos. Proteger o canal de comunicação. Fornecer controles de acesso rígidos aos armazenamentos de dados confidenciais. Não armazenar dados confidenciais em cookies persistentes. Não transmitir dados confidenciais utilizando o protocolo HTTP–GET.

Gerenciamento de sessão Limitar a duração da sessão. Proteger o canal. Criptografar o conteúdo dos cookies de autenticação. Proteger o estado da sessão contra acesso não autorizado.

Criptografia Não desenvolver sua própria criptografia. Utilizar recursos da plataforma testados. Manter dados descriptografados próximos do algoritmo. Utilizar o algoritmo e o tamanho de chave corretos. Evitar o gerenciamento de chaves (utilizar DPAPI). Mudar as chaves periodicamente. Armazenar chaves em um local restrito.

Manipulação de parâmetros Criptografar o estado de cookies confidenciais. Não confiar nos campos que o cliente pode manipular (seqüências de caracteres de consulta, campos de formulário, cookies ou cabeçalhos HTTP). Validar todos os
valores enviados a partir do cliente.

Gerenciamento de exceções Utilizar um tratamento de exceções estruturado. Não revelar detalhes confidenciais da implementação do aplicativo. Não registrar em log dados particulares, como senhas. Considerar uma estrutura de gerenciamento de exceções centralizado.

Auditoria e log Identificar comportamento mal–intencionado. Saber como é um tráfego normal. Executar atividades de auditoria e log em todas as camadas do aplicativo. Proteger o acesso aos arquivos de log. Fazer backup dos arquivos de log e os analisar regularmente.

A segurança deve difundir–se por todos os estágios do ciclo de desenvolvimento do produto e deve ser um dos pontos principais do projeto do aplicativo. Preste atenção, especialmente, ao projeto de uma estratégia rígida de autenticação e autorização. Lembre–se também de que a maioria dos ataques no nível do aplicativo utiliza dados com entrada mal–intencionada e uma validação fraca da entrada do aplicativo. As instruções apresentadas neste módulo ajudarão você com esses e outros aspectos complicados referentes ao projeto e à criação de aplicativos seguros.

fonte:msdn,MXStudio

[Anterior] [1] 2 3 4 5 [Próxima]

As propriedades e os métodos propostos neste código são:

Propriedades:

CurrentPage

Opcional. Obtém ou define a página atual.

PageCount

Necessário. O número de páginas para ser exibido.

QueryString

Opcional. Uma QueryString é necessária para ser transmitida entre as páginas. Querystrings devem ter este formato:

PageUrl

Necessário. A URL onde todos os links de navegação são exibidos.

LinkStyle

Opcional. Estilo CSS, código para as tags âncora de links criados pela classe.

SelectedPageStyle

Opcional. Estilo CSS para a página selecionada.

Width

Opcional. O numérico ou percentual de toda a largura do menu. Exemplos de valores válidos são “100%”, 500, 563, “55%”, etc.

Métodos:

RenderMenu

Necessário.Página gerada, menu de navegação do browser.

Este método deve ser chamado depois que todas as propriedades foram ajustadas.

sintaxe:

CurrentPage

Opcional. Obtém ou define a página atual.

PageCount

Necessário. O número de páginas para ser exibido.

QueryString

Opcional. Uma QueryString é necessária para ser transmitida entre as páginas. Querystrings devem ter este formato:

Dim qs qs = qs & "& s =" & Server.UrlEncode (request ( "s"))
qs = qs & "& t =" & Server.UrlEncode (request ( "t"))
qs = qs & "& u =" & Server.UrlEncode (request ( "u"))
Obj.Querystring = qs

PageUrl

Necessário. A URL onde todos os links de navegação são exibidos.

LinkStyle

Opcional. Estilo CSS, código para as tags âncora de links criados pela classe.

SelectedPageStyle

Opcional. Estilo CSS para a página selecionada.

Width

Opcional. O numérico ou percentual de toda a largura do menu. Exemplos de valores válidos são “100%”, 500, 563, “55%”, etc.

Métodos:

RenderMenu

Necessário.Página gerada, menu de navegação do browser.

Este método deve ser chamado depois que todas as propriedades foram ajustadas.

sintaxe:

Set object = New NaviPage

exemplo:

Dim p, qs´construir QueryString para passar de página em páginaqs = ""
qs = qs & "&s=" & Server.UrlEncode(request("s"))
qs = qs & "&t=" & Server.UrlEncode(request("t"))
qs = qs & "&u=" & Server.UrlEncode(request("u"))´cria nav menu
Set p = New NaviPage´set widthp.Width = "100%"´conjunto estilo da página Links
p.LinkStyle = "font-family:helvetica;font-size:12pt;"
´estilo de página selecionada
p.SelectedPageStyle = "font-family:helvetica;font-size:12pt;font-weight:bold;"
´número total de páginas "paginável" recordsetp.PageCount = 3
´conjunto da QueryString usada pelo recordset para gerar filasp.QueryString = qs
´definir a página onde cada página link deve apontar
p.PageUrl = Request.ServerVariables("SCRIPT_NAME")
´response.write o menu para o browserp.RenderMenu´liberar  memória
Set p = Nothing´impressões: [1] 2 3 [Próxima>>]
´Isso é exatamente a mesma classe qeu uso para fazer a paginação

código:

Dim p, qs

‘construir QueryString para passar de página em página

qs = “”

qs = qs & “&s=” & Server.UrlEncode(request(“s”))

qs = qs & “&t=” & Server.UrlEncode(request(“t”))

qs = qs & “&u=” & Server.UrlEncode(request(“u”))

‘cria nav menu

Set p = New NaviPage

‘set width

p.Width = “100%”

‘conjunto estilo da página Links

p.LinkStyle = “font-family:helvetica;font-size:12pt;”

‘estilo de página selecionada

p.SelectedPageStyle = “font-family:helvetica;font-size:12pt;font-weight:bold;”

‘número total de páginas “paginável” recordset

p.PageCount = 3

‘conjunto da QueryString usada pelo recordset para gerar filas

p.QueryString = qs

‘definir a página onde cada página link deve apontar

p.PageUrl = Request.ServerVariables(“SCRIPT_NAME”)

‘response.write o menu para o browser

p.RenderMenu

‘liberar  memória

Set p = Nothing

‘impressões: [1] 2 3 [Próxima>>]

‘Isso é exatamente a mesma classe que uso para fazer a paginação

código:

<%

Class NaviPage

       Private Sub Class_Initialize()

             CurrentPage = 1

             PageCount = 1

             QueryString = “”

             PageUrl = Request.ServerVariables(“SCRIPT_NAME”)

             LinkStyle = “font-family:helvetica;font-size:10pt;”

             SelectedPageStyle = “font-family:helvetica;font-size:12pt;font-weight:bold;”

             Width = “100%”

       End Sub

 

       Public Property Get CurrentPage

             dim p

 

             on error resume next

             p = clng(Request(“Page”))

             if err.number <> 0 then p = 1

             if p < 1 then p = 1

 

             CurrentPage = p

       End Property

 

       Public Property Let CurrentPage(byval page)

             CurrentPage = page

       End Property

 

       Public PageCount

 

       Public QueryString

 

       Public PageUrl

 

       Public LinkStyle

 

       Public SelectedPageStyle

 

       Public Width

 

       Public Sub RenderMenu()

             Dim strTempNavL, strTempNavR, strTempNavC, iEverySinglePage

 

             ‘input validação

             if clng(PageCount) < 1 Then

                    PageCount = 1

             end if

 

             If clng(CurrentPage) > clng(PageCount) Then

                    CurrentPage = PageCount

             End If

 

             If clng(CurrentPage) < 1 Then

                    CurrentPage = 1

             End If

 

             if Len(Trim(QueryString)) > 0 Then

                    if Left(QueryString, 1) = “&” Then

                           QueryString = Mid(QueryString, 2)

                    End If

             End If

 

 

             ‘criação menu

             If clng(CurrentPage) <> 1 Then

                    strTempNavL = strTempNavL & “<a href=”"” & PageUrl & “?page=” & _

                           clng(CurrentPage) – 1 & “&” & QueryString & _

                           “”" style=”"” & LinkStyle & “”">[&lt;&lt;&nbsp;back]</a>”

             else

                    strTempNavL = strTempNavL & “&nbsp;”

             End If

             If clng(CurrentPage) < clng(PageCount) Then

                    strTempNavR = strTempNavR & “<a href=”"” & PageUrl & “?page=” & _

                           clng(CurrentPage) + 1 & “&” & QueryString & _

                           “”" style=”"” & LinkStyle & “”">[next&nbsp;&gt;&gt;]</a>”

             else

                    strTempNavR = strTempNavR & “&nbsp;”

             End If

             iEverySinglePage = 1

             Do Until iEverySinglePage > PageCount

                    if iEverySinglePage = clng(CurrentPage) then

                           strTempNavC = strTempNavC & “[<span style=""" & _

                                  SelectedPageStyle & """>" & iEverySinglePage & _

                                  "</span>]&nbsp;&nbsp;”

                    else

                           strTempNavC = strTempNavC & “<a style=”"” & LinkStyle & _

                                  “”" href=”"” & PageUrl & “?page=” & _

                                  iEverySinglePage & “&” & QueryString & “”">” & _

                                  iEverySinglePage & “</a>&nbsp;&nbsp;”

                    end if

                    iEverySinglePage = iEverySinglePage + 1

             LOOP

 

 

             ‘render nav menu

             response.write “<table width=”"” & width & “”">” & vbCrLf

             response.write “<tr>” & vbCrLf

             response.write “<td valign=top align=left width=”"20%”">” & vbCrLf

             response.write strTempNavL & vbCrLf

             response.write “</td>” & vbCrLf

             response.write “<td valign=top align=center width=”"60%”">” & vbCrLf

             response.write strTempNavC & vbCrLf

             response.write “</td>” & vbCrLf

             response.write “<td valign=top align=right width=”"20%”">” & vbCrLf

             response.write strTempNavR & vbCrLf

             response.write “</td>” & vbCrLf

             response.write “</tr>” & vbCrLf

              response.write “</table>” & vbCrLf

       End Sub

End Class

%>