Hi,
I did a try. Let's look how you do feel. Step by step.

I love the diffuse term be a gradient vector between the brighter and the darker pixels, been both limits the sun color and the ambient color respectively. I usually compute the diffuse term as follows:
Code:
// Calculate the diffuse term:
float DiffuseFactor = pow ( ( 1.0f + dot(-vecSunDir.xyz, InNormal) ) * 0.5f, DiffuseGradient ); 
float3 texColor = texSample.rgb * lerp ( vecAmbient.rgb, vecSunColor.rgb, DiffuseFactor );


This way I take advantaje of the full range of the result of the dot product, scaling it to a 0<->1 range, so the back part of the mesh is slightly lightened instead of looking flat. DiffuseGradient controls the exponential of DiffuseFactor so you can displace the sun intensity to the back and the front. Then I multiply the texture sample by the interpolation between sun and ambient colors in reference to the computed DiffuseFactor.




I like to compute the specular term as a factor of the resultant vector obtained from the subtraction of the previously computed diffuse color to the sun color so it can be added to the diffuse with no big worries of going out of color ranges and been the sun color the brightest color you will find into the scene.

Code:
// Calculate the speculate component: 
float3 sunDirReflexion = reflect ( vecSunDir.xyz, InNormal );
float3 Specular =  ( vecSunColor.rgb - texColor ) * pow(saturate(dot(sunDirReflexion, InViewDir)), SpecularPower ) * texSample.a;
texColor += Specular * SpecularIntensity;


SpecularIntensity can do the color go out of range, but it is a good looking 'burn' effect. I like it larger than one.



I really do the enviroment reflexion implementation before computing the specular term.

Code:
// Calculate the enviroment reflection term 
float3 viewDirReflexion = reflect ( -InViewDir.xyz, InNormal );
float3 envSample = texCUBE ( sEnv, viewDirReflexion ).rgb;
texColor = lerp ( texColor, texSample.rgb*envSample, texSample.a );


Notice that I multiplied the enviroment sample by the raw texture color.




Click to reveal.. (alltogether)

alltoghether
Code:
// Tweakables: 
static const float DiffuseGradient   = 1.5f;      
static const float SpecularPower     = 16.0f;
static const float SpecularIntensity  = 2.5f;      


// Application fed data: 
const float4x4 matWorldViewProj; // World*view*projection matrix. 
const float4x4 matWorld;         // World matrix. 
const float4 vecAmbient;         // Ambient color. 
const float4 vecSunDir;          // The sun light direction vector. 
const float4 vecSunColor;        // The sun color 
const float4 vecViewPos;         // View position. 
  
texture entSkin1;  
sampler ColorMapSampler = sampler_state // Color map sampler. 
{   
  Texture = <entSkin1>;   
  MipFilter = Linear;   // required for mipmapping
}; 

texture mtlSkin1;
samplerCUBE sEnv = sampler_state { Texture = <mtlSkin1>; MipFilter = Linear; };

// Vertex Shader: 
void SpecularVS( 
  in float4 InPos: POSITION, 
  in float3 InNormal: NORMAL, 
  in float2 InTex: TEXCOORD0, 
  out float4 OutPos: POSITION, 
  out float2 OutTex: TEXCOORD0, 
  out float3 OutNormal: TEXCOORD1, 
  out float3 OutViewDir: TEXCOORD2) 
{ 
// Transform the vertex from object space to clip space: 
  OutPos = mul(InPos, matWorldViewProj); 
// Transform the normal from object space to world space: 
  OutNormal = normalize(mul(InNormal, matWorld));; 
// Pass the texture coordinate to the pixel shader: 
  OutTex = InTex; 
// Calculate a vector from the vertex to the view: 
  OutViewDir = vecViewPos - mul(InPos, matWorld); 
} 
 
// Pixel Shader: 
float4 SpecularPS( 
  in float2 InTex: TEXCOORD0, 
  in float3 InNormal: TEXCOORD1, 
  in float4 InViewDir: TEXCOORD2) : COLOR 
{ 
	// Incoming normals have to be normalized
	InNormal = normalize(InNormal); 
	InViewDir = normalize(InViewDir);
	// Fetch the pixel color from the color map: 
	float4 texSample = tex2D ( ColorMapSampler, InTex ); // texture alpha channel = specular map
	// Calculate the diffuse term:
	float DiffuseFactor = pow ( ( 1.0f + dot(-vecSunDir.xyz, InNormal) ) * 0.5f, DiffuseGradient ); 
	float3 texColor = texSample.rgb * lerp ( vecAmbient.rgb, vecSunColor.rgb, DiffuseFactor );
	// Calculate the enviroment reflection term 
	float3 viewDirReflexion = reflect ( -InViewDir.xyz, InNormal );
	float3 envSample = texCUBE ( sEnv, viewDirReflexion ).rgb;
	texColor = lerp ( texColor, texSample.rgb*envSample, texSample.a );
	// Calculate the speculate component: 
	float3 sunDirReflexion = reflect ( vecSunDir.xyz, InNormal );
	float3 Specular =  ( vecSunColor.rgb - texColor ) * pow(saturate(dot(sunDirReflexion, InViewDir)), SpecularPower ) * texSample.a;
	texColor += Specular * SpecularIntensity;
	return float4 ( texColor, 1.0f ); 
} 
 
// Technique: 
technique SpecularTechnique 
{ 
	pass P0 
	{ 
		ZEnable = True;
		ZWriteEnable = True;
		AlphaBlendEnable = False;
		VertexShader = compile vs_3_0 SpecularVS(); 
		PixelShader  = compile ps_3_0 SpecularPS(); 
	} 
}



Salud!